writing-plans

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

Updated Apr 7, 2026
One-click install
npx skills add https://github.com/NT-boop-star/BRMV-tract --skill writing-plans-nt-boop-star
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/NT-boop-star/BRMV-tract/tree/main/antigravity/skills/writing-plans
Command: npx skills add https://github.com/NT-boop-star/BRMV-tract --skill writing-plans-nt-boop-star

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 converts 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 (failing test, minimal implementation, verify, commit) with exact file paths and complete code. - Placeholder-Free Plans: Enforces concrete content in every step, banning TODOs, vague instructions, and undefined references. - Self-Review and Handoff: Includes a spec-coverage and consistency self-review checklist, plus an execution handoff offering subagent-driven or inline execution. - Use Case: After brainstorming a new feature spec, run this Skill to produce a dated plan document in docs/superpowers/plans/ that a subagent or engineer can implement task-by-task with checkbox tracking. ## Quick Start Use the writing-plans skill to turn my feature spec into a step-by-step 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?

Provide the spec or requirements, and the Skill produces a plan with a goal, architecture summary, tech stack, and tasks broken into 2-5 minute TDD steps. Each task lists exact files to create or modify, complete code, test commands with expected output, and commit steps.

What makes a good task breakdown for implementation plans?

Each step should be one action taking 2-5 minutes: write the failing test, run it to confirm failure, implement minimal code, verify it passes, then commit. Tasks must include exact file paths and complete code with no placeholders like TODO or TBD.

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 execution verifiable.

How are completed plans executed after writing?

After saving the plan, you choose between subagent-driven execution, which dispatches a fresh subagent per task with review between tasks, or inline execution, which runs tasks in the current session in batches with checkpoints.

What are common failure modes in AI-generated implementation plans?

Common failures include placeholder steps, vague instructions like add error handling, references to undefined functions, and inconsistent naming across tasks. The Skill's self-review checklist catches spec gaps, placeholders, and type inconsistencies before handoff.