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.