writing-plans

Generate executable implementation plans with TDD steps from a spec.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

writing-plans prevents costly, half-baked implementation work by forcing a clear, testable, file-by-file plan before touching non-trivial code changes.

Core Features & Use Cases

  • Spec-to-Task Decomposition: Breaks a multi-step implementation into small, buildable tasks that map directly to files created or modified.
  • TDD-Driven Execution Guidance: Ensures each task includes failing-test, minimal implementation, and passing-test steps with concrete commands and code.
  • Safe, Context-Free Engineering Assumptions: Designs the plan as if the implementer has little or no knowledge of the codebase, reducing integration mistakes.
  • Frequent Checkpoints and Commit Discipline: Encourages short step durations (2–5 minutes) and commits after completing each task.

Quick Start

Use the writing-plans skill to generate an implementation plan from your spec and save it to agents/tasks/active/<task-name>.md before starting any code changes.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down a complex refactoring spec into executable TDD steps?▼

Implementation planning decomposes a complex refactoring spec into small, testable tasks mapped to exact file paths. Each task includes failing-test, minimal implementation, and passing-test steps with concrete commands and expected outcomes.

What is the best way to plan risky architectural changes before writing code?▼

Test-first implementation planning prevents costly architectural mistakes by generating a file-by-file execution plan. It forces clear, testable tasks with commit checkpoints before any non-trivial code changes are made.

How do I decompose a multi-step feature into independent, testable git commits?▼

Task decomposition breaks feature work into bite-sized steps lasting 2–5 minutes each. The plan specifies exact commit checkpoints after completing every testable action, ensuring frequent, safe version control.

Can I generate an implementation plan for a codebase I am unfamiliar with?▼

Yes, implementation planning designs task steps assuming the implementer has little or no codebase knowledge. It provides exact file paths, commands, and expected outcomes to reduce integration mistakes.

When do I need to generate a formal implementation plan instead of directly editing code?▼

You need formal task decomposition for non-trivial tasks involving architectural decisions, risky refactors, or multi-step features. It prevents half-baked implementation by forcing a clear, testable plan before touching code.

Does implementation planning work for test-first development workflows?▼

Yes, TDD-driven execution guidance ensures each planned task includes failing-test, minimal implementation, and passing-test phases. It provides concrete commands and code snippets for a strict test-first workflow.