Skills

pdca

Installation
SKILL.md

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

Level Template Focus
Starter design-starter.template.md Simple structure, learning-oriented
Dynamic design.template.md Full-stack with BaaS integration
Enterprise design-enterprise.template.md MSA, Clean Architecture, K8s

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

Category Description Example
Match Design and code align API endpoint exists as designed
Missing in Code Designed but not implemented Missing validation logic
Missing in Design Implemented but not designed Extra utility function
Changed Implemented differently Different data structure

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

Current Next Command
None plan $pdca plan {feature}
plan design $pdca design {feature}
design do Start implementation
do check $pdca analyze {feature}
check (<90%) act $pdca iterate {feature}
check (>=90%) report $pdca report {feature}
report archive $pdca archive {feature}

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:

Template Purpose
plan.template.md Plan document structure
design.template.md Design document structure
design-starter.template.md Starter-level design
design-enterprise.template.md Enterprise-level design
analysis.template.md Gap analysis structure
report.template.md Completion report structure
do.template.md Implementation guide structure
Related skills

More from popup-studio-ai/bkit-codex

Installs
1
Repository
popup-studio-ai…it-codex
GitHub Stars
18
First Seen
Mar 29, 2026
Security Audits
Gen Agent Trust HubPass
SocketWarn
SnykPass