writing-plans

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

Updated Jan 31, 2023
One-click install
npx skills add https://github.com/Briian3306/Transporte --skill writing-plans-briian3306
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Briian3306/Transporte/tree/main/.agents/skills/writing-plans
Command: npx skills add https://github.com/Briian3306/Transporte --skill writing-plans-briian3306

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a feature spec into code without a plan leads to missed requirements, inconsistent types, and vague tasks that stall implementers. This Skill converts a spec into a complete, self-contained 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 interface signatures per task, and includes a self-review checklist for spec coverage and type consistency. - Execution Handoff: Saves plans to docs/superpowers/plans/ and offers subagent-driven or inline execution, with a reviewer prompt template for validating the finished plan. - Use Case: Given a spec for a new API endpoint, produce a plan where each task lists exact files to create or modify, the test code to write, the commands to run, and the commit message to use. ## Quick Start Use the writing-plans skill to turn my feature spec into a step-by-step implementation plan with TDD tasks.

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 the file structure first, then decompose work into tasks where each task has exact files, interface signatures, and bite-sized TDD steps: write failing test, run it, implement, verify, commit. End with a self-review against the spec for coverage and type consistency.

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

Each task should be the smallest unit with its own test cycle and 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.

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

Why do implementation plans fail during execution?▼

Plans fail when they contain placeholders like TODO or "add error handling", reference undefined types or functions, or use inconsistent names across tasks. Every step needs actual code, exact paths, and signatures that match between tasks.

Can a plan be executed by subagents instead of inline?▼

Yes. After saving the plan, you can choose subagent-driven execution, which dispatches a fresh subagent per task with review between tasks, or inline execution with batched tasks and checkpoints.