creating-a-plan
Creates a comprehensive easy to follow plan for building out a design. Use when creating an implementation plan from a design.
When & Why to Use This Skill
The 'Creating a Plan' skill is a specialized developer tool designed to bridge the gap between software design and technical execution. It automates the generation of comprehensive, step-by-step implementation plans that break down complex designs into bite-sized, actionable tasks. By emphasizing Test-Driven Development (TDD), DRY principles, and incremental delivery, this skill ensures high-quality code output and streamlined workflows for engineering teams, making it an essential asset for technical project planning and architectural implementation.
Use Cases
- Design-to-Code Workflow: Transform UI/UX mockups or architectural diagrams into a structured technical roadmap with granular coding tasks.
- Zero-Context Developer Onboarding: Generate detailed implementation guides that allow new or external developers to contribute to a codebase with minimal prior knowledge.
- TDD-Driven Feature Development: Create a rigorous plan that mandates writing failing tests before implementation, ensuring high test coverage and code reliability.
- Incremental Project Management: Organize large-scale software changes into manageable batches with specific commit milestones and exact file paths to prevent integration issues.
- Technical Documentation: Automatically produce 'plan.md' and 'batch.md' files that serve as a living record of the implementation strategy and technical decisions.
| name | creating-a-plan |
|---|---|
| description | Creates a comprehensive easy to follow plan for building out a design. Use when creating an implementation plan from a design. |
Overview
Write a comprehensive implementation plan
- Assume the implementor has zero context for the codebase
- Assume the implementor is a skilled developer
- Document everything they would need to know
- files that will be touched
- useful reference code, unit tests, and docs
- how to test changes
- Save all markdown docs next to the provided design
- Construct the plan as bite-sized tasks
Plan structure
- Write the plan to
plan.mdnext to the design - Fill out the plan template
Task Granularity
Each step is one action (2-5 minutes):
- "Write the failing test" - step
- "Run it to make sure it fails" - step
- "Implement the minimal code to make the test pass" - step
- "Run the tests and make sure they pass" - step
- "Commit" - step
Task Batches
- Group tasks into coherent batches
- Write each batch to its own file,
batch-<number>.md, next to the plan and design - Use the batch template
- Always use exact file paths
- Always use code snippets and not ambiguous instructions like "add validation"
- Always use exact commands with expected output
- Batches should be incremental and build on each other. Batch 1 must be implemented before batch 2
REMEMBER:
- DRY
- YAGNI
- TDD
- frequent commits