writing-plans

Generates sequential per-stage implementation plans from completed stage designs.

7|Updated May 13, 2026
One-click install
npx skills add https://github.com/DawnMoon1542/agents-skills --skill writing-plans-dawnmoon1542
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/DawnMoon1542/agents-skills/tree/main/workflow/writing-plans
Command: npx skills add https://github.com/DawnMoon1542/agents-skills --skill writing-plans-dawnmoon1542

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? After a multi-stage design is finalized, teams still need concrete, executable implementation plans. This Skill converts all completed stage designs into ordered, TDD-oriented plan files with explicit tasks, steps, tests, and verification commands, eliminating vague or transitional planning work. ## Core Features & Use Cases - Stage-by-Stage Plan Generation: Produces one dated plan file per stage under docs/plans/, following a fixed Stage → Task Group → Task → Step hierarchy with exact file paths, function signatures, and test scenarios. - Final-State-First Planning: Forbids transitional compatibility code such as adapters, dual reads/writes, feature flags, or temporary schemas, so plans target the final design directly. - Built-in Review and Handoff: Runs a self-check plus a structured plan-document review, updates the brainstorming index, then hands all plans to smart-exec-plan for continuous execution. - Use Case: After grill-with-docs finishes three stage designs for a feature, invoke this Skill to produce three reviewed implementation plans with TDD steps and verified build/test commands, ready for uninterrupted execution. ## Quick Start Use the writing-plans skill to generate implementation plans for all completed stage designs in docs/grill and record them in the brainstorming index.

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 multi-stage design into an implementation plan?

Read the brainstorming index, all stage design files, the context glossary, and referenced ADRs, then generate one plan file per stage under docs/plans/. Each plan decomposes the stage into task groups, tasks, and TDD steps with exact files and tests.

What structure should an executable development plan follow?

Use the hierarchy Stage → Task Group → Task → Step. Groups run strictly in sequence, each task is an atomic committable unit with clear file scope, and each step names exact files, functions, behavior requirements, and expected results.

Should implementation plans include backward compatibility tasks?

No, unless the final design explicitly requires long-term compatibility. Plans must avoid adapters, dual reads/writes, temporary schemas, and feature-flag migrations; intermediate tasks are allowed to be non-deployable since stages execute continuously.

When can plan writing start in a staged design workflow?

Only after all stage designs are complete and confirmed. Writing must not begin after a single stage, and implementation must not start until every stage plan is written, reviewed, and recorded in the brainstorming index.

What verification does each task in the plan require?

Each task runs only the tests and static checks directly tied to its target behavior, with the plan stating test files, scenarios, expected red-phase failures, and green-phase passes. Full build, lint, and test commands run once after the final stage.