writing-plans

Generate detailed implementation plans with tasks, files, tests, and commits.

Updated Feb 19, 2026
One-click install
npx skills add https://github.com/benjgrad/workout-ai --skill writing-plans-benjgrad
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/benjgrad/workout-ai/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/benjgrad/workout-ai --skill writing-plans-benjgrad

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing Plans helps engineers convert vague specs into concrete, actionable implementation plans. It ensures no critical steps are overlooked by documenting required files, tests, documentation references, and commit history before coding begins.

Core Features & Use Cases

  • Comprehensive task decomposition with precise file and test touchpoints for each step.
  • DRY, YAGNI, and TDD aligned planning that yields incremental, traceable commits.
  • Use Case: Given a feature idea, generate a full plan that a junior engineer can follow end-to-end.

Quick Start

Provide a complete, bite-sized implementation plan for a given feature, including tasks, files, tests, and commits.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down a software feature spec into actionable implementation steps?

To break down a software feature spec, you need detailed task decomposition that identifies required files, tests, and documentation references. This approach converts vague specs into concrete, incremental steps ready for direct execution.

What is the best way to plan complex engineering tasks for TDD and incremental commits?

Planning complex engineering tasks for TDD involves generating implementation plans that enforce DRY, YAGNI, and incremental commits. This ensures traceable version-control commits and precise test touchpoints across typical development workflows.

How do I generate an implementation plan that a junior engineer can execute end-to-end?

Generating an implementation plan for a junior engineer requires comprehensive task decomposition with precise file and test touchpoints for each step. The output provides a complete, bite-sized plan covering tasks, files, tests, and commits.

Can I use detailed planning to ensure no critical coding steps are overlooked?

Detailed planning prevents overlooked critical steps by documenting required files, tests, documentation references, and commit history before coding begins. It enforces best practices and outputs plans ready for direct execution by a sub-agent.

Does task decomposition work with standard version-control workflows?

Task decomposition works with standard version-control workflows by mapping each step to specific files, tests, and incremental commits. This yields traceable commit history aligned with DRY and TDD principles across development phases.