writing-plans

Generate a detailed engineering implementation plan from a requirements spec.

1|Updated May 5, 2026
One-click install
npx skills add https://github.com/yashs33244/my-mac-claude --skill writing-plans-yashs33244
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/yashs33244/my-mac-claude/tree/main/skills/superpowers/writing-plans
Command: npx skills add https://github.com/yashs33244/my-mac-claude --skill writing-plans-yashs33244

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Convert ambiguous requirements into a step-by-step implementation plan that a developer can follow without needing prior context.

Core Features & Use Cases

  • Multi-step plan authoring: Creates a complete implementation plan for a feature described by a spec or requirements.
  • File-focused decomposition: Maps which exact files to create/modify and assigns responsibilities to keep changes reliable and reviewable.
  • TDD-ready task breakdown: Structures work into bite-sized steps (test → verify fail → implement → verify pass → commit) to support dependable progress.
  • Execution handoff guidance: Provides an explicit handoff for subagent-driven or inline execution approaches, aligned to other Superpowers skills.

Quick Start

Tell your agent: create a writing-plans implementation plan for my feature spec, saving it under docs/superpowers/plans/ with exact file paths and TDD steps.

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 implementation steps?

Implementation planning decomposes a feature spec into bite-sized, file-level edit mapping and task sequencing. It maps exact files to create or modify, assigning responsibilities to keep changes reliable and reviewable.

How do I structure task decomposition for test-driven development?

Task decomposition for TDD structures work into bite-sized steps: write tests, verify failure, implement code, verify pass, then commit. This sequencing supports dependable progress and checkpoint test runs throughout the engineering workflow.

What is the best way to map file-level edits for a multi-step codebase change?

File-focused decomposition maps exact files to create or modify, assigning responsibilities to keep changes reliable and reviewable. This supports multi-step software changes across a codebase with limited prior context.

Can I generate git commit checkpoints for each step of an implementation plan?

Yes, the implementation plan structures work into bite-sized steps ending with git commits. Each step follows a TDD sequence of test, verify fail, implement, verify pass, and commit to support dependable progress.

How do I create a step-by-step engineering plan from ambiguous requirements?

Implementation planning converts ambiguous requirements into a step-by-step plan with exact code snippets and command examples. It produces DRY, YAGNI-aligned steps that a developer can follow without prior context.

Does implementation planning work for subagent-driven execution workflows?

Yes, the generated plan provides explicit handoff guidance for subagent-driven or inline execution approaches. It aligns with other engineering workflow skills to support dependable execution handoff.