writing-plans

Generate structured implementation plans from specs with tasks, files, tests, and validation steps.

12|2|Updated Mar 22, 2026
One-click install
npx skills add https://github.com/aman-2709/superpowers-ecc --skill writing-plans-aman-2709
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/aman-2709/superpowers-ecc/tree/main/skills/writing-plans
Command: npx skills add https://github.com/aman-2709/superpowers-ecc --skill writing-plans-aman-2709

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams convert a written spec or requirements into a comprehensive, executable implementation plan that outlines tasks, files to touch, tests, docs, and validation steps.

Core Features & Use Cases

  • Structured plan generation: Transforms a spec into a clear, task-by-task plan with defined boundaries and acceptance criteria.
  • Documentation-first approach: Emphasizes where to document decisions, files to touch, and testing strategies upfront.
  • Plan handoff and review: Produces a header, per-task steps, and a path for execution handoff to subagents or inline execution.
  • Use Case: When starting a new feature with limited context, run brainstorming to create a worktree and generate an actionable plan for implementation.

Quick Start

Announce at the start that you are using the writing-plans skill to create the implementation plan.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I convert a software spec into an actionable implementation plan?

Generating an implementation plan from a spec requires decomposing requirements into task-by-task steps detailing files to touch, tests, and validation. This structured approach ensures multi-step software engineering tasks have defined boundaries and acceptance criteria for execution.

What is the best way to structure task decomposition for multi-step software engineering projects?

Task decomposition for multi-step software engineering projects is best structured using a documentation-first approach. This method enforces a structured plan format with a header, per-task steps, and an execution handoff workflow to ensure subagents or inline execution have clear boundaries.

Can I generate a plan with testing and documentation steps from a formal requirements spec?

Yes, you can generate a plan with testing and documentation steps from a formal requirements spec. A structured plan generation process emphasizes where to document decisions and defines testing strategies upfront, ensuring both validation steps and docs are included in the task-by-task output.

Does spec-to-plan generation work for handing off execution to subagents?

Spec-to-plan generation works for handing off execution to subagents by producing a structured plan with a header and per-task steps. This format provides the defined boundaries and validation steps required for successful execution handoff to subagents or inline execution workflows.

When do I need a task-by-task implementation plan for software development?

You need a task-by-task implementation plan for software development when a team has a formal spec and needs to execute multi-step tasks across subsystems. It is required when you must detail files to touch, code changes, tests, docs, and validation steps before execution begins.