skills.rest
mpmf
mpmfCOMMUNITY
Explore all skills by this author →
GitHub

writing-plans

Generates detailed multi-task implementation plans with TDD steps from feature specifications.

Updated May 28, 2026
Search Tags:#tdd#implementation plan#task decomposition#spec#subagent#code planning#git commits
One-click install
npx skills add https://github.com/mpmf/SDD_Base --skill writing-plans-mpmf
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/mpmf/SDD_Base/tree/main/.opencode/skills/superpowers/writing-plans
Command: npx skills add https://github.com/mpmf/SDD_Base --skill writing-plans-mpmf

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a feature spec into code without a plan leads to missed requirements, vague tasks, and inconsistent execution. This Skill converts a specification into a complete, bite-sized implementation plan that an engineer with zero codebase context can follow task by task. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into 2-5 minute steps following TDD: write failing test, verify failure, implement, 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 spec for a new API endpoint, produce 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 my feature spec into a step-by-step TDD implementation plan saved under docs/superpowers/plans.

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 with 2-5 minute steps following TDD: write the failing test, verify it fails, implement minimally, 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 step should be one action taking 2-5 minutes, such as writing a failing test or running it to confirm failure. Tasks must contain actual code and exact commands with expected output, never placeholders like TODO or 'add error handling'.

When should a spec be split into multiple implementation plans?▼

Split the spec when it covers multiple independent subsystems. Each plan should produce working, testable software on its own, with one plan per subsystem rather than a single monolithic plan.

How do I review an implementation plan before executing it?▼

Check spec coverage by mapping each requirement to a task, scan for placeholder patterns like TBD or vague steps, and verify type and method name consistency across tasks. A reviewer subagent can also validate completeness and buildability.

What are the limitations of plan-driven development?▼

Plans assume the spec is complete and well-scoped; ambiguous requirements produce gaps that surface during execution. Very small changes may not justify a full plan, and plans require updating when implementation reveals incorrect assumptions.

Related Skills

Explore More Software Engineering Skills→
lapaixkemsdortshlee-svglapaixkemsdortshlee-svg

brainstorming

Shape vague product ideas into clear design directions before implementation.

Community
Advanced
Brite-NitesBrite-Nites

executing-plans

Execute structured plans by delegating each task to a fresh subagent.

Official
Advanced
edwinhuedwinhu
19

dev-plan-reviewer

Validate PLAN.md against SPEC.md for completeness and task readiness.

Community
Advanced
aslaiiaslaii

gsd-fast

Execute trivial tasks directly without spawning subagents or creating PLAN.md files.

Community
Basic