superpowers-writing-plans

Generate detailed implementation plans with file paths, code samples, and verification steps.

1|Updated Jan 25, 2026
One-click install
npx skills add https://github.com/klaaay/spec-toolkit --skill superpowers-writing-plans-klaaay
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: superpowers-writing-plans
Source: https://github.com/klaaay/spec-toolkit/tree/main/apps/spec-kit-app/public/commands-packages/superpowers/skills/superpowers-writing-plans
Command: npx skills add https://github.com/klaaay/spec-toolkit --skill superpowers-writing-plans-klaaay

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designs and outputs detailed, step-by-step implementation plans for developers who know little about a codebase, ensuring clear tasks, exact file paths, runnable examples, and verification steps.

Core Features & Use Cases

  • Structured planning: generates plans that specify precise file paths, code samples, and acceptance criteria.
  • Guided execution: aligns with DRY, YAGNI, and TDD to produce minimal, testable changes.
  • Use Case: when onboarding a new feature or fixing a complex bug, produces a comprehensive plan that a reasonably skilled engineer can execute with little domain context.

Quick Start

Provide a complete, step-by-step implementation plan for the target feature with precise file paths and runnable code examples.

Frequently Asked Questions about superpowers-writing-plans

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

FAQPage Schema
How do I generate an implementation plan for a new feature with specific file paths and code samples?

To generate an implementation plan, you provide a vague goal or feature description, and the tool outputs a detailed, end-to-end plan specifying precise file paths, runnable code samples, and explicit verification steps across your codebase.

What is the best way to create a structured bug fix plan for developers unfamiliar with a codebase?

Creating a structured bug fix plan involves generating task-level steps and acceptance criteria that align with DRY, YAGNI, and TDD principles, ensuring a reasonably skilled engineer can execute the changes with minimal domain context.

How does structured planning apply DRY, YAGNI, and TDD principles to software engineering tasks?

Structured planning applies DRY, YAGNI, and TDD principles by producing minimal, testable changes, generating task-level steps that avoid repetition, and including explicit verification steps to validate functionality throughout the implementation process.

Can I use task generation to create end-to-end plans for complex feature development?

Yes, you can use task generation for complex feature development to produce comprehensive plans that include a docs/plans path, precise file paths, and runnable code examples, turning vague goals into concrete, executable tasks.

Do I need prior codebase knowledge to execute generated implementation plans?

No, you do not need prior codebase knowledge to execute generated implementation plans, as they are specifically designed to guide developers with minimal context by providing exact file paths, runnable examples, and explicit verification steps.

What are the limitations of automated planning for bug fixes and feature development?

Automated planning for bug fixes and feature development relies on the initial context provided and focuses on minimal, testable changes, meaning it may not address highly complex architectural refactoring outside the scope of standard DRY, YAGNI, and TDD principles.