writing-plans

Generates detailed multi-task implementation plans from specs with TDD steps and commit checkpoints.

1|Updated Sep 10, 2026
One-click install
npx skills add https://github.com/thienty1207/Hotel_Staff --skill writing-plans-thienty1207
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/thienty1207/Hotel_Staff/tree/main/.baron/core/skills/superpowers/writing-plans
Command: npx skills add https://github.com/thienty1207/Hotel_Staff --skill writing-plans-thienty1207

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a spec or requirements document into an actionable implementation plan is error-prone: tasks end up too vague, placeholders slip in, and engineers without codebase context get stuck. This Skill produces a complete, bite-sized task plan that an engineer with zero project context can execute step by step. ## Core Features & Use Cases - Structured Plan Documents: Generates plans with a mandatory header (goal, architecture, tech stack, global constraints) saved to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md. - Bite-Sized TDD Tasks: Breaks work into tasks with exact file paths, interface contracts (consumes/produces), and 2-5 minute steps covering failing test, implementation, verification, and commit. - Placeholder Prevention & Self-Review: Enforces a no-placeholder policy (no TODOs or vague steps) and runs a self-review checklist for spec coverage, placeholder scans, and type consistency. - Use Case: Given a feature spec for a new API endpoint, produce a plan where each task lists exact files to create or modify, real test code, run commands with expected output, and git commit commands, then hand off to subagent-driven or inline execution. ## Quick Start Ask the AI to use the writing-plans skill to turn your spec into a step-by-step implementation plan before writing any code.

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 spec before coding?

Provide the spec and invoke the writing-plans skill before touching code. It maps the file structure, decomposes work into right-sized tasks with exact file paths and interfaces, and saves the plan to docs/superpowers/plans/ with a dated filename.

How to break a large feature spec into smaller tasks?

The skill checks scope first: if the spec spans multiple independent subsystems, it recommends splitting into separate plans, one per subsystem. Within a plan, each task is the smallest unit carrying its own test cycle and an independently testable deliverable.

What makes an implementation plan step too vague to execute?

Steps like "add appropriate error handling", "write tests for the above", or "TBD" are plan failures. Every step must contain actual content: real test code, exact run commands with expected output, and concrete commit commands.

Can the plan be executed by subagents after it is written?

Yes. After saving the plan, the skill offers two execution paths: subagent-driven development, which dispatches a fresh subagent per task with review between tasks, or inline execution with batch checkpoints using the executing-plans skill.

When should I not use a single implementation plan?

Avoid one plan when the spec covers multiple independent subsystems that cannot each produce working, testable software on their own. In that case, break the work into separate plans during brainstorming so each plan delivers standalone value.