writing-plans

Generate detailed multi-task implementation plans with TDD steps from feature specifications.

Updated Sep 16, 2022
One-click install
npx skills add https://github.com/ryuya-matsunawa/dotfiles --skill writing-plans-ryuya-matsunawa
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/ryuya-matsunawa/dotfiles/tree/main/agents/.agents/skills/writing-plans
Command: npx skills add https://github.com/ryuya-matsunawa/dotfiles --skill writing-plans-ryuya-matsunawa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a feature spec into code without a plan leads to missed requirements, inconsistent types across tasks, and vague steps that stall implementation. This Skill converts a spec or requirements document into a complete, bite-sized implementation plan that an engineer with zero codebase context can execute task by task. ## Core Features & Use Cases - Structured Plan Generation: Produces a plan document with a required header, global constraints, file structure mapping, and tasks broken into 2-5 minute steps following TDD (failing test, run, implement, verify, commit). - Quality Enforcement: Bans placeholders like TODO or "add error handling", requires exact file paths and complete code in every step, and includes a self-review checklist for spec coverage, placeholder scans, and type consistency. - Execution Handoff: Saves plans to docs/superpowers/plans/ and offers subagent-driven or inline execution, plus a reviewer prompt template for dispatching a plan review subagent. - Use Case: Given a spec for a new API endpoint, produce a dated plan file where each task lists exact files to create or modify, interface signatures consumed and produced, and runnable test commands with expected output. ## Quick Start Ask the agent to use the writing-plans skill to turn your feature spec into a step-by-step TDD implementation plan saved under docs/superpowers/plans/.

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 from a feature spec?▼

Start with a plan header covering goal, architecture, and tech stack, then map the file structure before decomposing work into tasks. Each task lists exact files, interface contracts, and bite-sized TDD steps: write the failing test, run it, implement minimally, verify, and commit.

How to break a large spec into implementation tasks?▼

If the spec spans multiple independent subsystems, split it into separate plans, one per subsystem, each producing working testable software. Within a plan, size tasks so each ends with an independently testable deliverable a reviewer could approve or reject on its own.

What makes a good task granularity in a coding plan?▼

Each step should be one action taking 2-5 minutes, such as writing a failing test, running it to confirm failure, implementing minimal code, verifying the pass, and committing. Fold setup and scaffolding into the task whose deliverable needs them.

When should I not use a detailed implementation plan?▼

Avoid full plans for trivial single-step changes where task decomposition overhead exceeds the work itself. The skill targets multi-step tasks from a spec; it also defers to sub-project specs when scope covers multiple independent subsystems.

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 placeholders like TODO or vague error-handling steps, and confirm type and method names stay consistent across tasks. Fix issues inline and add tasks for uncovered requirements.