writing-plans

Create file-by-file implementation plans with atomic tasks and test steps.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill removes ambiguity from multi-step software work by turning specs and requirements into detailed implementation plans that an engineer can follow with little to no prior context.

Core Features & Use Cases

  • File-by-File Decomposition: Maps exactly which files to create or modify and why each one exists.
  • Atomic Task Planning: Breaks work into small, testable steps that support TDD, frequent commits, and reviewable progress.
  • Execution Readiness: Includes testing commands, expected outcomes, review loops, and a clear handoff for implementation.
  • Use Case: A product manager or engineer can hand over a feature spec and receive a structured plan that covers scope, dependencies, validation, and deployment-ready sequencing.

Quick Start

Use the writing-plans skill to turn this feature specification into a detailed implementation plan with file-level tasks and test steps.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn feature specs into file-by-file implementation plans?

To turn feature specs into implementation plans, you provide the specification to receive a detailed breakdown mapping exact file paths to create or modify, complete with atomic task sequencing and clear execution handoff.

What is task decomposition for multi-step software engineering?

Task decomposition for software engineering is breaking multi-step feature requirements into atomic, testable chunks that support test-driven development, frequent commits, and reviewable progress before code changes begin.

How do I plan test-first development steps for agentic code execution?

You plan test-first steps by generating an execution-ready structure that includes testing commands, expected outcomes, chunked review loops, and commit guidance for seamless agentic development handoff.

Do I need exact file paths to create a structured build plan?

Yes, exact file paths are required to create a structured build plan, ensuring the decomposition accurately maps which files to create or modify and why each one exists within the execution sequence.

What's the best way to break down brainstormed features into reviewable execution chunks?

The best way to break down brainstormed features is mapping them into atomic tasks with scope, dependencies, validation steps, and deployment-ready sequencing to ensure reviewable progress throughout implementation.

When should I not use an implementation plan for code changes?

You should avoid using an implementation plan for simple, single-file modifications that require no task decomposition, dependency mapping, or test-first sequencing to execute successfully.