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.