writing-plans

Generate detailed implementation plans from specs with tasks, file changes, and tests.

3|5|Updated Apr 26, 2026
One-click install
npx skills add https://github.com/casualjim/pi-superpowers --skill writing-plans-casualjim
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/casualjim/pi-superpowers/tree/main/skills/writing-plans
Command: npx skills add https://github.com/casualjim/pi-superpowers --skill writing-plans-casualjim

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing and maintaining comprehensive implementation plans for multi-step tasks, ensuring engineers know exactly what to touch, test, and commit before coding.

Core Features & Use Cases

  • Generate end-to-end task plans from a given spec, including file touchpoints, testing guidance, and release notes.
  • Enforce DRY, YAGNI, TDD practices and provide structured plan documents for handoffs between planning and development.
  • Use in scenarios where multiple subsystems or complex requirements exist and you need a single cohesive plan.

Quick Start

Write a complete implementation plan for the provided spec and save it under docs/plans/YYYY-MM-DD-<feature-name>.md.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I generate an implementation plan from a software spec?

To generate an implementation plan from a spec, you need detailed task decomposition that defines file-level touchpoints, testing requirements, and commit granularity. This ensures engineers know exactly what to modify and verify before coding begins.

What is the best way to break down multi-subsystem specs for development?

Breaking down multi-subsystem specs requires generating a cohesive implementation plan that guides tasks, file changes, and reviews across design and verification. It enforces DRY, YAGNI, and TDD practices to maintain structured development.

How do I document file touchpoints and testing guidance for complex tasks?

Documenting file touchpoints and testing guidance involves creating structured plan documents saved as markdown files. These documents map out specific code changes, test considerations, and release notes to facilitate seamless handoffs between planning and development.

Can I use task decomposition plans for single feature development?

Yes, task decomposition plans apply to both single and multi-subsystem specs. They provide executable implementation guidance detailing file ownership, commit granularity, and verification steps tailored to the specific scope of the feature.

When do I need a detailed implementation plan before coding?

You need a detailed implementation plan when facing complex requirements or multi-step tasks. It ensures engineers have a cohesive roadmap with file touchpoints, testing guidance, and release notes before writing any code.

Does implementation planning enforce TDD and DRY practices?

Implementation planning enforces TDD, DRY, and YAGNI practices by integrating test considerations and structured task decomposition directly into the workflow. This ensures the generated plan guides clean, testable development.