PDCA (Plan-Do-Check-Act) methodology knowledge. Covers documentation-first development, design-implementation sync, continuous improvement. Triggers: PDCA, plan, design, check, act, 계획, 설계, 検証, 改善
/plugin marketplace add popup-studio-ai/bkit-claude-code/plugin install bkit@bkit-marketplaceThis skill is limited to using the following tools:
┌─────────────────────────────────────────────────────────┐
│ PDCA Cycle │
├──────────────┬──────────────────────────────────────────┤
│ Plan │ Planning and documentation │
│ │ → Record in docs/01-plan/ │
├──────────────┼──────────────────────────────────────────┤
│ Do │ Design-based implementation │
│ │ → Code while referencing design docs │
├──────────────┼──────────────────────────────────────────┤
│ Check │ Design vs implementation analysis │
│ │ → Record results in docs/03-analysis/ │
├──────────────┼──────────────────────────────────────────┤
│ Act │ Learning and improvement │
│ │ → Write report in docs/04-report/ │
└──────────────┴──────────────────────────────────────────┘
Purpose: Document what, why, and how
# {Feature} Plan
## Objectives
- What will be achieved?
## Background
- Why is it needed?
## Scope
- What's included
- What's excluded
## Success Criteria
- How to determine completion?
## Timeline (optional)
- Expected duration
Purpose: Document detailed design before implementation
# {Feature} Design Document
## Architecture
- Component structure
- Data flow
## Data Model
- Entity definitions
- Relationships
## API Specification
- Endpoints
- Request/Response
## UI/UX (if applicable)
- Screen layouts
- User flows
Purpose: Implement based on design
Rules:
1. Read design document first
2. Track work with TodoWrite
3. If implementation must differ from design, update design first
4. Move to Check phase after completion
Purpose: Analyze differences between design and implementation
# {Feature} Analysis Results
## Design Match Rate
- N%
## Differences
- In design but not in implementation
- In implementation but not in design
- Implemented differently than designed
## Issues
- Problems discovered
- Root cause analysis
## Recommended Actions
- Fix implementation / Update design
Purpose: Organize learnings and prepare for next cycle
# {Feature} Completion Report
## Result Summary
- Completed items
- Incomplete items
## Learnings
- What went well
- What to improve
## Next Steps
- Follow-up work
- Next cycle plan
docs/
├── 01-plan/ # [P] Planning
│ ├── _INDEX.md # List and status
│ ├── requirements.md # Overall requirements
│ └── features/
│ └── {feature}.plan.md # Feature-specific plans
│
├── 02-design/ # [D] Design
│ ├── _INDEX.md
│ ├── architecture.md # Overall architecture
│ ├── data-model.md # Data model
│ ├── api-spec.md # API specification
│ └── features/
│ └── {feature}.design.md
│
├── 03-analysis/ # [C] Analysis
│ ├── _INDEX.md
│ ├── gap-analysis/ # Design-implementation gaps
│ └── issues/ # Issue analysis
│
└── 04-report/ # [A] Reports
├── _INDEX.md
├── changelog.md # Change history
└── features/
└── {feature}.report.md
1. Check docs/02-design/
2. If no design → Write design document first
3. If design exists → Implement based on design
4. After implementation → Suggest Check
1. Check docs/03-analysis/issues/
2. Document root cause analysis
3. Implement fix
4. Update analysis document
1. Analyze current state (Check)
2. Create improvement plan (Plan)
3. Update design documents (Design)
4. Implement refactoring (Do)
5. Analyze results and report (Check, Act)
| Level | Description | Documentation Level |
|---|---|---|
| Level 1 | Basic | Only README |
| Level 2 | Planning | Requirements documented |
| Level 3 | Design | Design documented |
| Level 4 | Analysis | Design-implementation sync |
| Level 5 | Continuous Improvement | Full PDCA cycle operation |
1. Documentation First
- Design before code
- Reference design during implementation
- Update documents on changes
2. No Guessing
- Check documents if uncertain
- Ask if not in documents
- Record, don't assume
3. Continuous Sync
- Design and implementation always match
- Take immediate action on gaps
- Periodic verification
4. Learn & Improve
- Learn from each cycle
- Improve processes
- Accumulate team knowledge
❌ Wrong understanding:
Mapping entire Pipeline to PDCA
(Plan=Phase1-3, Do=Phase4-6, Check=Phase7-8, Act=Phase9)
✅ Correct understanding:
Run PDCA cycle within each Phase
Phase N
├── Plan: Plan what to do in this Phase
├── Design: Detailed design
├── Do: Execute/implement
├── Check: Verify/review
└── Act: Confirm and move to next Phase
┌─────────────────────────────────────────────────────────────────┐
│ Development Pipeline │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Phase 1 ──→ Phase 2 ──→ Phase 3 ──→ ... ──→ Phase 9 │
│ │ │ │ │ │
│ [PDCA] [PDCA] [PDCA] [PDCA] │
│ │
└─────────────────────────────────────────────────────────────────┘
| Situation | PDCA | Pipeline |
|---|---|---|
| New project (non-developer) | ✅ | ✅ |
| New project (experienced) | ✅ | Optional |
| Feature addition/modification | ✅ | ❌ |
| Bug fix | ✅ | ❌ |
| Non-development AI work | ✅ | ❌ |
Key Point:
development-pipeline/: Complete Pipeline knowledgephase-1-schema/ ~ phase-9-deployment/: Phase-by-phase guidesThis skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.