writing-plans

Generate implementation plans from specs with task lists and commit steps.

66|20|Updated Dec 30, 2025
One-click install
npx skills add https://github.com/cooker/wxHm --skill writing-plans-cooker
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/cooker/wxHm/tree/main/.cursor/skills/writing-plans
Command: npx skills add https://github.com/cooker/wxHm --skill writing-plans-cooker

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps engineers and product teams convert a written spec or requirements into a thorough, executable implementation plan, ensuring all steps are captured before any code changes.

Core Features & Use Cases

  • Structured planning: produce a clear, bite-sized task list with ownership, dependencies, and acceptance criteria.
  • TDD-oriented planning: include testing steps and verification criteria to guide development and QA.
  • Documentation mapping: specify necessary docs, stubs, and save locations (e.g., docs/plans) for traceability.
  • Use Case: given a feature spec, generate a plan that outlines the files to touch, tests to write, and commit strategy.

Quick Start

Use the writing-plans skill to generate an implementation plan from a feature spec and save it to docs/plans/YYYY-MM-DD-<feature-name>.md

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 feature spec into an implementation plan with task breakdown?

To turn a spec into an implementation plan, provide the feature spec to generate a structured task breakdown with concrete file paths, testing steps, and explicit commit strategy. This ensures engineers can execute tasks with zero context by following bite-sized, reproducible steps saved as plan artifacts.

What is the best way to structure implementation plans for zero-context execution?

The best way to structure implementation plans for zero-context execution is using a fixed format containing a header, bite-sized task list, concrete file paths, testing steps, and explicit commit steps. This structure guarantees reproducible execution and clear ownership for engineers.

Can I include testing steps and documentation mapping in my task breakdown?

Yes, you can include testing steps and documentation mapping in your task breakdown. The generated plan enforces TDD-oriented planning by outlining necessary docs, stubs, and specific save locations like docs/plans for traceability, alongside acceptance criteria and verification steps.

How do I save implementation plans for future traceability?

To save implementation plans for traceability, generate the plan artifact and save it to the docs/plans directory using a date-prefixed naming convention like docs/plans/YYYY-MM-DD-<feature-name>.md. This ensures thorough documentation mapping and historical tracking of spec changes.

Does this planning approach work without requiring external dependencies?

Yes, this planning approach works without requiring external dependencies. It operates independently to parse your feature spec and output a fixed plan structure with task lists and commit steps, requiring no additional components or environmental setup to generate the documentation artifacts.

When do I need to generate a fixed plan structure from a spec?

You need to generate a fixed plan structure from a spec when your project requires clear, bite-sized task breakdowns and thorough documentation before any code changes. It is essential for guiding engineers with zero context and ensuring reproducible execution through explicit commit steps.