writing-plans

Create implementation plans with tasks, files, tests, and commit checklists.

Updated May 21, 2026
One-click install
npx skills add https://github.com/jaehun0630/cline-superpowers --skill writing-plans-jaehun0630
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/jaehun0630/cline-superpowers/tree/main/packages/skills/writing-plans
Command: npx skills add https://github.com/jaehun0630/cline-superpowers --skill writing-plans-jaehun0630

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams convert vague specs into concrete implementation plans by defining tasks, files, tests, and steps before coding, ensuring alignment and traceability.

Core Features & Use Cases

  • Structured planning: Create decomposition-driven task trees that map to exact file changes, tests, and docs.
  • Plan persistence: Save plans to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md for versioned reference.
  • Iterative refinement: Break down complex projects into bite-sized tasks that can be committed incrementally.
  • Use Case: When starting a new feature with a spec, generate a comprehensive plan that guides engineers through design, implementation, review, and verification.

Quick Start

Generate a complete, executable implementation plan from a given spec, detailing tasks, files, tests, and a commit strategy.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create an implementation plan from a software specification?

To create an implementation plan from a software specification, define tasks, files, tests, and steps before coding to ensure alignment. This process converts vague specs into concrete blueprints by decomposing complex projects into bite-sized tasks mapped to exact file changes.

What is task decomposition in software engineering planning?

Task decomposition in software engineering planning is the process of breaking down complex project requirements into structured, bite-sized tasks. It creates decomposition-driven task trees that map directly to exact file changes, tests, and documentation for incremental commits.

How do I document multi-step software tasks for my development team?

You document multi-step software tasks by generating comprehensive implementation plans that outline files, tasks, tests, and review steps. Save these plans to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md to provide versioned reference and ensure traceability across the team.

When do I need to generate a plan document before coding a new feature?

You need to generate a plan document before coding when starting a new feature with a spec or set of requirements. Generating a plan beforehand guides engineers through design, implementation, review, and verification, ensuring alignment and traceability before any code is written.

Can I iteratively refine an implementation plan as project requirements change?

Yes, you can iteratively refine an implementation plan as project requirements change by breaking down complex projects into bite-sized tasks. This structured planning approach allows tasks to be committed incrementally, supporting continuous adjustment throughout the development lifecycle.