writing-plans

Generates detailed implementation plans with bite-sized TDD tasks from a spec.

1|Updated Sep 13, 2026
One-click install
npx skills add https://github.com/silentFellow/public-dotfiles --skill writing-plans-silentfellow
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/silentFellow/public-dotfiles/tree/main/agents/skills/writing-plans
Command: npx skills add https://github.com/silentFellow/public-dotfiles --skill writing-plans-silentfellow

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, self-contained plan that an engineer with zero project context can execute task by task. ## Core Features & Use Cases - Structured Plan Generation: Produces a plan document with a mandatory header (goal, architecture, tech stack, spec reference, global constraints) saved to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md. - Bite-Sized TDD Tasks: Decomposes work into tasks with exact file paths, interface contracts (consumes/produces), and 2-5 minute steps following the write-failing-test, run, implement, verify, commit cycle. - Quality Gates: Enforces a no-placeholders policy, a self-review checklist (spec coverage, placeholder scan, type consistency), and an optional plan document reviewer subagent prompt template. - Use Case: Given a feature spec for a new API endpoint, generate a plan where each task lists exact files to create or modify, real test code, run commands with expected output, and commit commands, then hand off to subagent-driven or inline execution. ## Quick Start Use the writing-plans skill to turn my spec into a step-by-step implementation plan with TDD tasks.

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?▼

Start with a header capturing goal, architecture, tech stack, and global constraints copied from the spec. Then map the file structure, decompose work into right-sized tasks with exact file paths and interface contracts, and break each task into bite-sized TDD steps ending in a commit.

How granular should tasks be in an implementation plan?▼

Each task should be the smallest unit with its own test cycle and an independently testable deliverable. Individual steps within a task should take 2-5 minutes, such as writing one failing test, running it, implementing the minimal code, verifying it passes, and committing.

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.

What are common mistakes in AI-generated implementation plans?▼

Common failures include placeholders like TODO or 'add error handling', steps that describe what to do without showing code, references to undefined types or functions, and inconsistent naming across tasks. A self-review pass for spec coverage, placeholders, and type consistency catches these.

How is a finished plan executed after writing it?▼

The plan offers two execution paths: subagent-driven development, 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.