writing-plans

Generates detailed implementation plans with bite-sized TDD tasks from feature specifications.

Updated Dec 19, 2024
One-click install
npx skills add https://github.com/DNepovim/yadm --skill writing-plans-dnepovim
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/DNepovim/yadm/tree/main/.claude/plugins/cache/claude-plugins-official/superpowers/5.0.6/skills/writing-plans
Command: npx skills add https://github.com/DNepovim/yadm --skill writing-plans-dnepovim

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers often start coding multi-step features without a clear roadmap, leading to missed requirements, inconsistent types, and vague tasks. This Skill turns a spec or requirements document into a complete, executable implementation plan before any code is touched. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into 2-5 minute steps following TDD (failing test, minimal implementation, verify, commit) with exact file paths and complete code blocks. - Placeholder-Free Plans: Enforces rules against TODOs, vague steps, and undefined references so any engineer can execute the plan with zero codebase context. - Self-Review and Execution Handoff: Includes a spec-coverage and type-consistency checklist, then offers subagent-driven or inline execution of the finished plan. - Use Case: After brainstorming a new API feature, use this Skill to produce a dated plan document in docs/superpowers/plans/ that a fresh engineer or subagent can implement task-by-task. ## Quick Start Use the writing-plans skill to create an implementation plan for the feature described in my spec document.

Frequently Asked Questions about writing-plans

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write an implementation plan before coding a feature?▼

Start from a spec or requirements document, map out which files will be created or modified, then decompose the work into bite-sized TDD tasks. Each task lists exact file paths, complete code, test commands with expected output, and a commit step.

What makes a good task breakdown for a coding plan?▼

Each step should be one action taking 2-5 minutes: write the failing test, run it to confirm failure, implement minimal code, verify it passes, then commit. Steps must contain actual code and exact commands, never placeholders like TODO or add error handling.

When should a spec be split into multiple implementation plans?▼

Split when the spec covers multiple independent subsystems. Each plan should produce working, testable software on its own, so one plan per subsystem keeps scope manageable and execution verifiable.

How do I verify an implementation plan covers the whole spec?▼

Run a self-review after writing: check each spec requirement maps to a task, scan for placeholder patterns, and confirm type and method names stay consistent across tasks. Fix issues inline and add tasks for any uncovered requirements.

What are the limitations of plan-driven development?▼

Plans assume a finished spec exists, so they are not suited for exploratory work where requirements are still unclear. They also require discipline to keep code blocks complete, since vague steps cause implementers to get stuck.