writing-plans

Convert multi-step specifications into executable implementation plans with TDD task sequencing.

Updated Apr 24, 2026
One-click install
npx skills add https://github.com/Cain-Ish/claude-code-plugin --skill writing-plans-cain-ish
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Cain-Ish/claude-code-plugin/tree/main/skills/writing-plans
Command: npx skills add https://github.com/Cain-Ish/claude-code-plugin --skill writing-plans-cain-ish

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

writing-plans converts a vague or incomplete multi-step spec into a clear, file-by-file implementation plan that an engineer can execute with test-driven development.

Core Features & Use Cases

  • Scope checking for subsystem separation: recommends splitting the work into independent plans when a spec spans multiple subsystems.
  • Concrete, decomposed task steps: breaks the work into bite-sized 2–5 minute actions with explicit create/modify/test file paths.
  • Strict no-placeholder execution format: requires code and test content for each step, along with specific commands and expected outcomes.

Quick Start

Use writing-plans when you have a spec or requirements for a multi-step task, and tell your agent to produce a plan saved under docs/plans for execution task-by-task with TDD.

Frequently Asked Questions about writing-plans

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn a product spec into a TDD implementation plan?

To turn a product spec into a TDD implementation plan, you decompose the work into bite-sized 2–5 minute tasks with explicit file edits, concrete code, and specific test commands. This step-by-step approach minimizes execution ambiguity during build execution.

What is file decomposition in implementation planning?

File decomposition in implementation planning is the process of mapping file structure up front and breaking multi-step engineering specifications into independent, executable tasks. It ensures each step contains concrete code and commands for test-driven development.

How do I structure engineering workflows for multi-step feature builds?

Structure engineering workflows for multi-step feature builds by enforcing a strict plan document format with bite-sized step granularity. This requires splitting work into independent plans when a spec spans multiple subsystems to ensure clear task sequencing.

Does implementation planning work for specs that span multiple subsystems?

Implementation planning works for multi-subsystem specs by recommending you split the work into independent plans. This scope checking ensures each plan remains focused on a single subsystem rather than mixing unrelated engineering workflows.

Why do implementation plans require no placeholders for test writing?

Implementation plans require no placeholders for test writing to minimize execution ambiguity. Enforcing a strict execution format with concrete code, test content, and specific commands ensures each step is actionable and verifiable.