writing-plans

Writes detailed implementation plans with bite-sized TDD tasks and exact file paths.

Updated Jan 2, 2025
One-click install
npx skills add https://github.com/mcinnisd/gymbro --skill writing-plans-mcinnisd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/mcinnisd/gymbro/tree/main/.agents/skills/writing-plans
Command: npx skills add https://github.com/mcinnisd/gymbro --skill writing-plans-mcinnisd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers and AI agents often receive vague specs and produce incomplete or inconsistent implementation plans, leading to stalled work, placeholder content, and mismatched interfaces between tasks. This Skill enforces a rigorous plan-writing process so every plan is complete, testable, and executable by someone with zero codebase context. ## Core Features & Use Cases - Structured Plan Documents: Generates plans with a mandatory header (goal, architecture, tech stack, global constraints) saved to docs/superpowers/plans/ with dated filenames. - Bite-Sized TDD Tasks: Breaks work into tasks with exact file paths, interface contracts (consumes/produces), and 2-5 minute steps following the failing-test, implement, verify, commit cycle. - Placeholder Prevention & Self-Review: Forbids TODOs and vague steps, then runs a self-review checklist covering spec coverage, placeholder scans, and type consistency across tasks. - Use Case: After brainstorming a feature spec, invoke this Skill to produce a complete implementation plan that a subagent or junior engineer can execute task-by-task without getting stuck. ## Quick Start Ask the AI to use the writing-plans skill to create an implementation plan for your approved feature spec.

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 for a coding agent?

Structure the plan with a header stating goal, architecture, and tech stack, then decompose into tasks with exact file paths, interface contracts, and TDD steps. Each step should be a 2-5 minute action with actual code, ending in a commit.

How to break a feature spec into implementation tasks?

Map the file structure first, then draw task boundaries where a reviewer could reject one task while approving its neighbor. Each task must end with an independently testable deliverable and declare what it consumes and produces for neighboring tasks.

What makes an implementation plan fail during execution?

Plans fail when they contain placeholders like TODO or vague steps such as add error handling, reference undefined types, or have inconsistent naming across tasks. A self-review for spec coverage, placeholders, and type consistency catches these issues.

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.

Can the plan be executed by subagents after writing?

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