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: