writing-plans

Create structured implementation plans for multi-step software tasks.

20|1|Updated Dec 10, 2025
One-click install
npx skills add https://github.com/galangryandana/superpowers-for-my-own-workflow --skill writing-plans-galangryandana
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/galangryandana/superpowers-for-my-own-workflow/tree/main/skills/writing-plans
Command: npx skills add https://github.com/galangryandana/superpowers-for-my-own-workflow --skill writing-plans-galangryandana

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams create comprehensive implementation plans for multi-step tasks when requirements are unclear, ensuring all steps, files, tests, docs, and commits are defined before coding.

Core Features & Use Cases

  • Comprehensive task decomposition for complex features.
  • DRY, YAGNI, and TDD-aligned planning to guide development.
  • Documentation-ready plan files saved under the docs/plans directory for traceability.
  • Reusable templates and structured checkpoints for auditing and reviews.

Quick Start

Announce at start: "I'm using the writing-plans skill to create the implementation plan." Save plans to: docs/plans/YYYY-MM-DD-<feature-name>.md Then outline the plan using the standard template, including:

  • Task N: [Component Name]
  • Create: exact/path/to/file.py
  • Modify: exact/path/to/existing.py:123-145
  • Test: tests/exact/path/to/test.py And commit after each step.

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 for multi-step software tasks with zero context?

To create an implementation plan with zero context, you define task decomposition, file modifications, tests, and commit steps from a spec, outputting a structured document to the docs/plans directory.

What's the best way to structure TDD-aligned implementation plans for complex features?

The best way to structure TDD-aligned implementation plans is to enforce DRY and YAGNI principles, mapping each task to specific file changes and test paths before coding begins.

How do I decompose requirements into exact file changes and commit steps before coding?

You decompose requirements into exact file changes and commit steps by breaking down the spec into sequential tasks, specifying path modifications, test files, and commits for each component.

Can I generate documentation-ready plan files for traceability when requirements are unclear?

Yes, you can generate documentation-ready plan files under docs/plans with structured checkpoints, ensuring all files, tests, and commits are defined even when requirements are unclear.

Does this planning approach work for multi-file tasks without existing context?

Yes, this planning approach works for multi-file tasks without existing context by applying structured templates that guide development from initial requirements through testing and documentation.

Why enforce DRY and YAGNI principles during task decomposition for software engineering?

Enforcing DRY and YAGNI principles during task decomposition prevents code duplication and unnecessary features, ensuring the implementation plan remains focused and maintainable across multiple files.