writing-plans

Convert software specs into implementation plans with tasks and milestones.

2|Updated May 8, 2026
One-click install
npx skills add https://github.com/xotong/claude-marketplace --skill writing-plans-xotong
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/xotong/claude-marketplace/tree/main/plugins/superpowers/skills/writing-plans
Command: npx skills add https://github.com/xotong/claude-marketplace --skill writing-plans-xotong

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing plans often fail to translate vague specs into concrete, executable steps, causing ambiguity and project delays.

Core Features & Use Cases

  • Generate decomposition plans that map to repository structure and task granularity.
  • Define file touchpoints, tests, docs, and commits for each task.
  • Use cases include drafting feature plans, refactor plans, or new module introductions with explicit delivery milestones.

Quick Start

Create a complete implementation plan for a new feature and save it under docs/superpowers/plans with the date stamp.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn a software spec into an implementation plan with actionable tasks?

An implementation plan maps specs to repository structure by defining file touchpoints, tests, docs, and commit cadence for each task. It breaks down feature-level work into actionable tasks with explicit delivery milestones and clear task boundaries.

What is the best way to create a plan for refactoring an existing system module?

The best way to plan refactoring an existing system is to generate a decomposition plan that maps to repository structure and task granularity, defining explicit delivery milestones, file touchpoints, and boundaries to ensure executable, unambiguous steps.

How do I decompose a new feature spec into file touchpoints and tests?

Decompose a feature spec by mapping its requirements to task granularity within your repository structure, explicitly defining file touchpoints, necessary tests, documentation, and commit cadence for each actionable task to ensure clear ownership and boundaries.

Does this planning approach work for introducing a new module with version control?

Yes, this approach works for introducing a new module by generating a decomposition plan that maps to repository structure and task granularity, explicitly defining commits, file touchpoints, and tests to ensure clear delivery milestones under version control.

Why do vague software specs cause project delays during task decomposition?

Vague specs cause project delays because they fail to translate into concrete, executable steps, creating ambiguity. Generating a detailed implementation plan with clear task boundaries, file touchpoints, and ownership prevents this execution breakdown.

Where should I save implementation plan artifacts for feature-level work?

Save implementation plan artifacts for feature-level work to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md, ensuring the plan includes a commit cadence, file touchpoints, and clear task boundaries for ready-to-implement execution.