writing-plans

Convert implementation specifications into decomposed, testable task plans.

Updated May 7, 2026
One-click install
npx skills add https://github.com/TumeloRamaphosa/StudEx-Valley-OS --skill writing-plans-tumeloramaphosa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/TumeloRamaphosa/StudEx-Valley-OS/tree/main/.claude/skills/superpowers/skills/writing-plans
Command: npx skills add https://github.com/TumeloRamaphosa/StudEx-Valley-OS --skill writing-plans-tumeloramaphosa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing implementation plans from a spec is slow and error-prone, especially when engineers lack context about the codebase and tooling.

Core Features & Use Cases

  • Spec-to-Plan Decomposition: Break multi-subsystem requirements into independent, testable sub-project plans.
  • File-First Task Mapping: Identify exact files to create/modify and lock decomposition boundaries before implementation.
  • Bite-Sized TDD Execution Steps: Produce per-task, per-step instructions that include failing tests, command runs, minimal implementations, passing test verification, and frequent commits.
  • Plan Persistence & Review Handoff: Save the plan to docs/superpowers/plans with an optional override, then offer execution options including subagent-driven or inline execution.

Quick Start

Use the writing-plans skill when you have a multi-step engineering spec and need a complete, testable implementation plan before touching code.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I decompose a software specification into testable implementation tasks?

Implementation planning for multi-subsystem features works by breaking specifications into independent, testable sub-projects. It locks file decomposition boundaries and produces bite-sized TDD steps with concrete commands, ensuring clear execution handoff for any engineer.

What is the best way to create a TDD execution plan spanning multiple files?

Creating a TDD execution plan requires producing per-task, per-step instructions that include failing tests, command runs, minimal implementations, passing test verification, and frequent git commits. This ensures multi-file feature work is verifiable and isolated.

Can I save generated engineering plans to a custom directory for later review?

Generated implementation plans are saved to docs/superpowers/plans by default, with an optional override for custom output locations. This persistence enables subsequent review and execution handoff to subagents or inline workflows.

Does implementation planning work for features spanning multiple subsystems?

Implementation planning applies to multi-step feature work spanning multiple files and potentially multiple subsystems. It decomposes requirements into independent, testable sub-project plans with explicit file paths and concrete commands.

How do I hand off an implementation plan to another developer?

To hand off an implementation plan, generate a decomposed task plan with required headers, explicit file paths, concrete commands, and expected outcomes. The saved plan enables an unfamiliar engineer to execute end-to-end via subagent or inline execution.