writing-plans

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

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/chhpt/skills --skill writing-plans-chhpt
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/chhpt/skills/tree/main/skills/writing-plans
Command: npx skills add https://github.com/chhpt/skills --skill writing-plans-chhpt

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers often start coding from a spec without a clear roadmap, leading to missed requirements, vague tasks, and inconsistent execution. This Skill turns a spec or requirements document into a complete, step-by-step implementation plan that an engineer with zero codebase context can follow. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into 2-5 minute steps following TDD: write failing test, verify failure, implement, verify pass, commit. - No-Placeholder Enforcement: Requires exact file paths, complete code blocks, exact commands with expected output, and bans vague steps like "add error handling". - Self-Review Checklist: Validates spec coverage, scans for placeholder patterns, and checks type/name consistency across tasks before handoff. - Execution Handoff: Offers subagent-driven or inline execution paths after saving the plan to docs/superpowers/plans/. - Use Case: After brainstorming a new feature spec, use this Skill to produce a dated plan document with checkbox-tracked tasks that a subagent or junior engineer can implement independently. ## Quick Start Use the writing-plans skill to create an implementation plan from my feature spec before writing any code.

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?

Provide the spec or requirements document and the Skill maps out the file structure, then decomposes the work into tasks with exact file paths, failing tests, minimal implementations, and commit steps. Each step is a 2-5 minute action following TDD.

What makes a good task breakdown for implementation plans?

Each step should be one concrete action: write the failing test, run it to verify failure, implement minimal code, run tests to verify pass, then commit. Steps must include actual code and exact commands, never placeholders like TODO or "add validation".

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 tasks independently executable.

Can the generated plan be executed by a subagent automatically?

Yes. After saving the plan, the Skill offers subagent-driven execution, which dispatches a fresh subagent per task with review between tasks, or inline execution with batched checkpoints using the executing-plans skill.

Why do implementation plans fail during execution?

Plans fail when they contain placeholders, reference undefined functions, or use inconsistent names across tasks. The built-in self-review checks spec coverage, scans for placeholder patterns, and verifies type and method name consistency before handoff.