writing-plans

Translate specifications into executable implementation plans with traceable tasks.

11|2|Updated Aug 1, 2025
One-click install
npx skills add https://github.com/sc30gsw/claude-code-customes --skill writing-plans-sc30gsw
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/sc30gsw/claude-code-customes/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/sc30gsw/claude-code-customes --skill writing-plans-sc30gsw

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Write comprehensive implementation plans from a spec or requirements before touching code, ensuring the engineer has a complete, contextual roadmap.

Core Features & Use Cases

  • Translates a spec into a concrete, task-level plan that documents what files to touch, what to implement, how to test, and how to document.
  • Produces bite-sized tasks that promote DRY, YAGNI, and TDD principles, with clear commit guidance.
  • Supports teams by providing a repeatable process for turning vague requirements into an actionable plan, ensuring alignment and traceability.

Quick Start

Read the spec and generate a complete implementation plan broken into bite-sized tasks.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I translate a software specification into an actionable implementation plan?

To translate a software specification into an implementation plan, you decompose requirements into bite-sized, task-level steps. This process documents which files to touch, what tests to write, and outlines clear commit guidance for engineers.

What is the best way to break down requirements for TDD before coding?

The best way to break down requirements for TDD is by generating structured tasks that enforce DRY and YAGNI principles. This ensures every implementation step has corresponding test cases and documentation references mapped out beforehand.

Can I use this to generate task breakdowns for vague engineering requirements?

Yes, you can use this to generate task breakdowns for vague engineering requirements. It provides a repeatable process that transforms ambiguous specifications into traceable, executable roadmaps, ensuring team alignment before development starts.

Does this planning approach support multi-step software project roadmaps?

Yes, this planning approach supports multi-step software project roadmaps by design. It translates project-level specifications into precise, executable implementation plans with structured decomposition and repeatable templates.

Why should I create an implementation plan before touching code?

You should create an implementation plan before touching code to ensure you have a complete, contextual roadmap. This prevents scope creep by enforcing structured decomposition, traceable tasks, and adherence to DRY and YAGNI principles.

What limitations exist when applying spec-to-plan templates to large engineering tasks?

When applying spec-to-plan templates to large engineering tasks, the primary limitation is the quality of the initial specification. The structured decomposition relies heavily on having sufficiently detailed requirements to generate actionable, bite-sized tasks.