Writing Implementation Plans
Independent PiSkill directory guide. The original skill remains hosted by Superpowers.
What is Writing Implementation Plans?
Turns an approved software design into an execution-ready implementation plan with small tasks, dependencies, test cycles, file-level changes, and verification steps.
What does Writing Implementation Plans do?
Writing Implementation Plans is a Superpowers skill for converting an approved software design into a detailed sequence of small implementation tasks. It assumes the developer or agent executing the plan may have limited project context, so each step should include the relevant files, code intent, tests and verification.
Who is Writing Implementation Plans best for?
- Teams separating design from implementation
- AI coding workflows that need durable execution plans
- Developers breaking large changes into reviewable tasks
- Projects where another agent will execute the plan later
Common use cases
- Turn an approved feature design into atomic engineering tasks
- Document exact files and tests for each implementation step
- Create a plan that can survive a context reset
- Prepare work for a separate execution agent
How does Writing Implementation Plans work?
The skill writes the plan as a sequence of small tasks with explicit paths, expected code changes, test steps and commands. It favors frequent verification and small commits so implementation can proceed incrementally instead of depending on a large undocumented leap.
Key benefits
- Creates durable execution context
- Reduces ambiguity for a separate implementation agent
- Makes testing part of each task rather than an afterthought
- Encourages small, reviewable units of work
Things to know
- A detailed plan takes time to prepare
- Plans can become stale when implementation reveals new constraints
- The quality of the plan depends on the approved design and codebase understanding
Compatible tools
Frequently asked questions
What should an AI implementation plan include?
Why make tasks small?
Related skills
Create Implementation Plan
Creates a deterministic implementation plan for features, refactors, architecture, infrastructure, or upgrades with atomic phases, dependencies, validation criteria, and execution-ready tasks.
Brainstorming
Turns an initial product or feature idea into a clearer design by exploring intent, requirements, alternatives, constraints, and trade-offs before implementation begins.
Executing Plans
Executes a written implementation plan systematically, tracks task progress, runs the required checks, and stops when blockers or failed verification make continued execution unsafe.
GitHub Issue Creator
Turns verified work context into a focused GitHub issue with scope, reproduction or rationale, acceptance criteria, dependencies, and actionable next steps.
Product Roadmap Update
Creates or reprioritizes a product roadmap when initiatives, dependencies, timelines, or new information change, including Now/Next/Later planning and trade-off decisions.
Dispatching Parallel Agents
Delegates independent problems to separate agents in parallel with isolated context, useful when multiple unrelated bugs or workstreams can be investigated concurrently.