writing-plans

Generates detailed multi-task implementation plans from specs with TDD steps and exact file paths.

1|Updated Jun 24, 2026
One-click install
npx skills add https://github.com/maopujie10-sys/Bailongma --skill writing-plans-maopujie10-sys
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/maopujie10-sys/Bailongma/tree/main/src/skills/superpowers/writing-plans
Command: npx skills add https://github.com/maopujie10-sys/Bailongma --skill writing-plans-maopujie10-sys

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 implementations. 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 - Structured Plan Documents: Produces plans with a mandatory header, global constraints, file structure mapping, and per-task blocks listing exact files to create or modify. - Bite-Sized TDD Steps: Breaks every task into 2-5 minute steps following the write-failing-test, run, implement, verify, commit cycle with complete code and exact commands. - Self-Review and Handoff: Runs a spec-coverage, placeholder, and type-consistency check, then offers subagent-driven or inline execution of the finished plan. - Use Case: Given a spec for a new API endpoint, produce a dated plan file in docs/superpowers/plans/ where each task lists exact file paths, interface signatures, test code, and commit commands. ## Quick Start Use the writing-plans skill to turn this feature spec into a step-by-step implementation plan with tests and commits.

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?

Start with a plan header covering goal, architecture, and tech stack, then map the file structure before defining tasks. Each task lists exact files to create or modify, interface signatures, and bite-sized TDD steps with complete code and commit commands.

How to break a large spec into implementation tasks?

If the spec spans multiple independent subsystems, split it into separate plans, one per subsystem, each producing working testable software. Within a plan, size tasks so each ends with an independently testable deliverable a reviewer could approve or reject on its own.

What makes an implementation plan step too vague?

Steps are plan failures if they contain placeholders like TBD, 'add appropriate error handling', or 'write tests for the above' without actual code. Every step must show the exact code, the exact command to run, and the expected output.

When should I not use a detailed written implementation plan?

Skip the full plan for trivial single-file changes or exploratory spikes where requirements are still unclear. The planning overhead pays off only for multi-step tasks where an implementer needs complete context to work independently.

How are completed plans executed after writing?

Plans are saved to docs/superpowers/plans/ with a dated filename, then executed either by dispatching a fresh subagent per task with review between tasks, or inline in the same session with batched execution and checkpoints.