PDCA Unified Skill

Unified Skill for managing the complete PDCA cycle: Plan, Design, Do, Check, Act.

Usage

$pdca plan {feature}      Create plan document
$pdca design {feature}    Create design document
$pdca do {feature}        Implementation guide
$pdca analyze {feature}   Gap analysis (Check phase)
$pdca iterate {feature}   Auto-improvement (Act phase)
$pdca report {feature}    Completion report
$pdca status              Current PDCA status
$pdca next                Next phase suggestion
$pdca archive {feature}   Archive completed PDCA
$pdca cleanup             Clean archived features

Phase Flow

Plan -> Design -> Do -> Check(analyze) -> Act(iterate) -> Report -> Archive
  |                                          |
  |                                          v
  |                                    (if < 90%)
  |                                    iterate -> re-analyze
  |                                          |
  v                                          v
[Complete]                             (if >= 90%)
                                       Report -> Archive

Phase Progress Visualization

[Plan] -> [Design] -> [Do] -> [Check] -> [Act] -> [Report]

Status indicators:
  [Phase] done     -> phase completed
  [Phase] active   -> currently working
  [Phase] pending  -> not yet started

Plan Phase

Create a planning document for the feature.

Steps

1. •Call bkit_pdca_plan(feature, level) MCP tool
2. •Write template to docs/01-plan/features/{feature}.plan.md
3. •Fill in sections: Goals, Scope, Success Criteria, Schedule
4. •Call bkit_complete_phase(feature, "plan") when done

Key Sections

• •Overview and Purpose
• •Scope (In/Out)
• •Functional Requirements
• •Non-Functional Requirements
• •Success Criteria (Definition of Done)
• •Risks and Mitigation
• •Architecture Considerations
• •Convention Prerequisites

Output Path

docs/01-plan/features/{feature}.plan.md

Design Phase

Create a technical design document based on the plan.

Prerequisites

Plan document must exist. If missing, suggest: $pdca plan {feature} first.

Steps

1. •Verify plan exists (required prerequisite)
2. •Call bkit_pdca_design(feature, level) MCP tool
3. •Write template to docs/02-design/features/{feature}.design.md
4. •Fill in: Architecture, Data Model, API Spec, Test Plan
5. •Call bkit_complete_phase(feature, "design") when done

Level-Specific Templates

Output Path

docs/02-design/features/{feature}.design.md

Do Phase

Guide implementation based on the design document.

Prerequisites

Design document must exist. If missing, suggest: $pdca design {feature} first.

Steps

1. •Verify design exists (required prerequisite)
2. •Reference design document during implementation
3. •Follow implementation order from design
4. •Call bkit_pre_write_check(filePath) before each file write
5. •Call bkit_post_write(filePath, linesChanged) after significant changes
6. •Call bkit_complete_phase(feature, "do") when done

Implementation Guide

Provide a structured implementation plan:

1. •Data Layer: Types, models, API client
2. •Business Logic: Services, custom hooks, state management
3. •UI Components: Base components, pages, error handling
4. •Integration: Connect API to UI, loading states, error handling

Output Path

docs/02-design/features/{feature}.do.md (optional implementation tracking)

Analyze Phase (Check)

Compare design document vs implementation to find gaps.

Steps

1. •Call bkit_pdca_analyze(feature) MCP tool
2. •Read design document: docs/02-design/features/{feature}.design.md
3. •Scan implementation code in relevant directories
4. •Compare design items vs implemented items
5. •Calculate Match Rate: (implemented / total_design_items) * 100
6. •Write analysis to docs/03-analysis/{feature}.analysis.md

Decision After Analysis

• •If matchRate >= 90%: suggest $pdca report {feature}
• •If matchRate < 90%: suggest $pdca iterate {feature}

Gap Categories

Output Path

docs/03-analysis/{feature}.analysis.md

Iterate Phase (Act)

Auto-fix identified gaps to improve match rate.

Steps

1. •Read gap list from analysis document
2. •Fix identified gaps in code (prioritize "Missing in Code" items)
3. •Re-run analysis: $pdca analyze {feature}
4. •Repeat until matchRate >= 90% or max 5 iterations
5. •Call bkit_complete_phase(feature, "act") when done

Iteration Rules

• •Maximum iterations: 5 (configurable via bkit.config.json)
• •Stop conditions: matchRate >= 90% OR maxIterations reached
• •If max iterations reached without 90%: report current state and suggest user review

Report Phase

Generate a completion report for the feature.

Prerequisites

Match rate should be >= 90%. Warn if below.

Steps

1. •Verify matchRate >= 90% (warn if below)
2. •Gather data from plan, design, analysis documents
3. •Generate completion report
4. •Write to docs/04-report/{feature}.report.md
5. •Include: completed items, quality metrics, learnings

Report Sections

• •Summary (completion rate, duration)
• •Related Documents (plan, design, analysis links)
• •Completed Items (functional, non-functional requirements)
• •Quality Metrics (match rate, code quality score)
• •Lessons Learned (keep, problem, try)
• •Next Steps

Output Path

docs/04-report/{feature}.report.md

Status

Show current PDCA progress for all active features.

Steps

1. •Call bkit_get_status(feature) MCP tool
2. •Display feature, phase, matchRate, iteration count
3. •Show progress visualization

Output Format

PDCA Status
---
Feature: {feature}
Phase: {current_phase}
Match Rate: {rate}%
Iteration: {count}/{max}
---
[Plan] done -> [Design] done -> [Do] done -> [Check] active -> [Act] pending

Next

Suggest the next PDCA phase based on current state.

Steps

1. •Call bkit_pdca_next(feature) MCP tool
2. •Display recommended next action with command

Phase Guide

Archive

Archive completed PDCA documents.

Steps

1. •Verify report completion (phase = "completed" or matchRate >= 90%)
2. •Create docs/archive/YYYY-MM/{feature}/ folder
3. •Move documents from original locations
4. •Update .pdca-status.json: phase = "archived"

Documents Archived

• •docs/01-plan/features/{feature}.plan.md
• •docs/02-design/features/{feature}.design.md
• •docs/03-analysis/{feature}.analysis.md
• •docs/04-report/{feature}.report.md

Cleanup

Clean up archived features from .pdca-status.json.

Steps

1. •Read archived features from status
2. •Display list with timestamps
3. •Delete selected features from status
4. •Archive documents remain in docs/archive/

Template References

Templates are available in references/ directory: