writing-plans

Generates detailed multi-task implementation plans from specs with TDD steps and exact file paths.

Updated Jul 30, 2026
One-click install
npx skills add https://github.com/johsquaree/claude-basic-docs --skill writing-plans-johsquaree
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/johsquaree/claude-basic-docs/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/johsquaree/claude-basic-docs --skill writing-plans-johsquaree

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a spec or requirements document into an actionable implementation plan is error-prone: tasks end up too vague, placeholders slip in, and engineers without codebase context get stuck. This Skill produces a complete, bite-sized task breakdown that an engineer with zero project context can execute directly. ## Core Features & Use Cases - Structured Plan Documents: Generates plans with a mandatory header (goal, architecture, tech stack, global constraints) and per-task blocks listing exact files to create or modify, interfaces consumed and produced, and checkbox steps. - Bite-Sized TDD Steps: Each task is decomposed into 2-5 minute steps following a test-driven cycle: write failing test, verify failure, implement, verify pass, commit. - Placeholder Prevention & Self-Review: Enforces a no-placeholder policy (no TODOs or vague steps) and runs a self-review checklist covering spec coverage, placeholder scan, and type consistency across tasks. - Use Case: Given a feature spec for a new API endpoint, produce a plan saved to docs/superpowers/plans/ with tasks covering models, routes, and tests, then hand off to subagent-driven or inline execution. ## Quick Start Ask the AI to use the writing-plans skill to turn your spec document into a step-by-step implementation plan 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 spec before coding?

Provide the spec and invoke the writing-plans skill before touching code. It maps the file structure, decomposes work into right-sized tasks with exact file paths, and breaks each task into 2-5 minute TDD steps ending in a commit.

What makes a good task breakdown for an implementation plan?

Each task should be the smallest unit carrying its own test cycle, with an independently testable deliverable. Fold setup and scaffolding into the task that needs them, and split only where a reviewer could reject one task while approving its neighbor.

How do I avoid placeholders like TODO in generated implementation plans?

The skill enforces a no-placeholder policy: every step must contain actual code, exact commands, and expected outputs. A self-review pass scans for red flags like TBD, vague error-handling steps, or references to undefined functions.

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 reviewable and deliverables independent.

What happens after the implementation plan is written?

The plan is saved to docs/superpowers/plans/ with a dated filename, then you choose an execution mode: subagent-driven development with a fresh subagent per task and review gates, or inline execution with batched checkpoints.