writing-plans

Generate implementation plans with task steps and file changes from a spec.

1|Updated Apr 5, 2026

Search Tags:#planning #documentation #workflows #software-engineering #task-decomposition #plan-generation #spec-processing

Ready to run

npx skills add https://github.com/mortenbroesby/playground --skill writing-plans-mortenbroesby

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/mortenbroesby/playground/tree/main/.skills/writing-plans
Command: npx skills add https://github.com/mortenbroesby/playground --skill writing-plans-mortenbroesby

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing Plans helps teams convert a spec or requirements document into a deterministic, task-by-task implementation plan before touching code. It ensures every required file, test, and documentation item is identified and organized into small, auditable steps.

Core Features & Use Cases

Comprehensive task decomposition: breaks a spec into concrete steps, files to touch, tests to write, and docs to check.
Structured planning: maps responsibilities across design decisions, code, tests, and documentation, with clear ownership.
Plan export and saving: saves plans to a versioned path (docs/superpowers/plans/...) to enable traceability.
Best-practice guidance: encourages TDD, DRY, and YAGNI in plan generation.

Quick Start

Provide a project spec in plain language or attach a brief description, and I will generate a complete implementation plan.

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 specification into an actionable implementation plan?▼

To turn a software specification into an implementation plan, you provide the spec in plain language and the system decomposes it into concrete, auditable steps. It identifies required files, tests, and documentation, mapping responsibilities across design decisions and code changes.

What is task decomposition for multi-step software projects?▼

Task decomposition for multi-step software projects is the process of breaking a spec into small, auditable implementation steps. It maps out specific files to modify, tests to write, and documentation to check before any code is touched.

How do I generate a step-by-step plan that maps out file changes from a requirements document?▼

You generate a plan with file changes by submitting your requirements document for structured processing. The system analyzes the spec and produces a deterministic, task-by-task plan detailing exact file modifications, required tests, and commit-ready changes.

Can I use this for product design and project scoping, or is it limited to software engineering?▼

You can use this for product design and project scoping, as well as software engineering. It applies to any multi-step project requiring detailed tasks and file mapping, generating comprehensive plans from plain language or brief descriptions.

Does the generated implementation plan follow best practices like TDD and DRY?▼

The generated implementation plan encourages best practices like TDD, DRY, and YAGNI during plan generation. It structures tasks to align with these principles while organizing required files, tests, and documentation into clear, auditable steps.

Where are the generated implementation plans saved for version control and traceability?▼

Generated implementation plans are saved to a versioned path at docs/superpowers/plans/ to enable traceability. This ensures every required file, test, and documentation item identified during task decomposition remains accessible.