writing-plans

Generates detailed implementation plans with bite-sized TDD tasks from feature specifications.

Updated Aug 22, 2026
One-click install
npx skills add https://github.com/farslab/claude-skills --skill writing-plans-farslab
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/farslab/claude-skills/tree/main/writing-plans
Command: npx skills add https://github.com/farslab/claude-skills --skill writing-plans-farslab

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a feature spec into code without a plan leads to missed requirements, inconsistent types, and vague tasks that stall implementers. This Skill converts a spec into a complete, self-contained implementation plan that an engineer with zero codebase context can execute task by task. ## Core Features & Use Cases - Structured Plan Documents: Produces plans 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: Breaks work into tasks with exact file paths, interface contracts (consumes/produces), and 2-5 minute steps covering failing test, verification, minimal implementation, and commit. - 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, generate a plan where each task lists exact files to create or modify, real test code, run commands with expected output, and commit commands. ## Quick Start Use the writing-plans skill to turn my feature 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 feature spec?▼

Start with a header covering goal, architecture, tech stack, and spec path, then map the file structure before defining tasks. Each task lists exact files to create or modify, interface contracts, and bite-sized TDD steps ending in a commit.

How granular should tasks be in an implementation plan?▼

Each step should be one action taking 2-5 minutes, such as writing a failing test, running it, implementing minimal code, and committing. A task is the smallest unit carrying its own test cycle with an independently testable deliverable.

What makes an implementation plan fail during execution?▼

Plans fail when they contain placeholders like TODO or 'add error handling', reference undefined types or functions, or have inconsistent naming between tasks. A self-review pass checking 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, creating one plan per subsystem. Each plan should produce working, testable software on its own rather than depending on sibling plans.

How are completed implementation plans executed?▼

Plans offer two execution modes: subagent-driven development, which dispatches a fresh subagent per task with review between tasks, or inline execution with batched tasks and checkpoints. The plan header declares the required execution sub-skill.