writing-plans

Converts specs into detailed multi-step implementation plans with bite-sized TDD tasks.

Updated Sep 19, 2026
One-click install
npx skills add https://github.com/Ab0umar/selrs.cc.BU --skill writing-plans-ab0umar
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Ab0umar/selrs.cc.BU/tree/main/.codex/plugins/cache/openai-curated/superpowers/dc902811/skills/writing-plans
Command: npx skills add https://github.com/Ab0umar/selrs.cc.BU --skill writing-plans-ab0umar

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, files are missed, and engineers without codebase context get stuck. This Skill produces a complete, step-by-step plan that an engineer with zero context can follow. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into 2-5 minute steps following a TDD cycle (failing test, verify failure, minimal implementation, verify pass, commit). - No-Placeholder Enforcement: Requires exact file paths, complete code blocks, and exact commands with expected output in every step. - Self-Review Checklist: Validates spec coverage, scans for placeholder patterns, and checks type consistency across tasks before handoff. - Use Case: Given a feature spec for a new API endpoint, generate a plan saved to docs/superpowers/plans/ with checkbox-tracked tasks, then hand off to subagent-driven or inline execution. ## Quick Start Use the writing-plans skill to turn this feature spec into a detailed implementation plan with TDD tasks and exact file paths.

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?▼

Map out the file structure first, then decompose the work into tasks where each step is one 2-5 minute action: write a failing test, verify it fails, implement minimal code, verify it passes, and commit. Include exact file paths and complete code in every step.

What makes a good task breakdown for TDD implementation plans?▼

Each task should target one component with clearly listed files to create, modify, and test. Steps follow the red-green-commit cycle with exact commands and expected output, and no placeholders like TODO or 'add error handling' are allowed.

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 reviewable.

How do I verify an implementation plan is complete before coding?▼

Run a self-review checking three things: every spec requirement maps to a task, no placeholder patterns remain, and type and method names are consistent across tasks. A reviewer subagent can also check completeness, spec alignment, and buildability.

What are the limitations of plan-driven development?▼

Plans assume a spec already exists, so they do not replace brainstorming or requirements gathering. They also require discipline to keep steps concrete; vague steps without code blocks cause implementers to get stuck.