writing-plans

Generates detailed multi-task implementation plans from specifications before coding begins.

Updated Aug 14, 2026
One-click install
npx skills add https://github.com/bill80362/laravel-thread-admin --skill writing-plans-bill80362
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/bill80362/laravel-thread-admin/tree/main/.github/superpowers/writing-plans
Command: npx skills add https://github.com/bill80362/laravel-thread-admin --skill writing-plans-bill80362

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers often jump into coding without a clear roadmap, leading to missed requirements, inconsistent naming, and untestable work. This Skill turns a specification into a complete, step-by-step implementation plan that any engineer (or AI agent) with zero codebase context can execute. ## Core Features & Use Cases - Structured Task Breakdown: Splits work into small TDD-style tasks with exact file paths, test code, implementation code, and commit steps. - Placeholder Enforcement: Forbids vague steps like "add error handling" — every step must contain real, executable content. - Self-Review Checklist: Verifies spec coverage, placeholder-free content, and type/name consistency across tasks before handoff. - Execution Handoff: Offers subagent-driven or inline execution modes after the plan is saved to docs/superpowers/plans/. - Use Case: Given a feature spec for a new API endpoint, produce a dated plan document where each task includes a failing test, minimal implementation, verification run, and git commit. ## Quick Start Ask the AI to use the writing-plans skill to create an implementation plan from your feature specification document.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I write an implementation plan from a feature specification?

Define the file structure first, then break work into tasks where each task ends with an independently testable deliverable. Each step within a task should be a 2-5 minute action: write a failing test, run it, implement minimal code, verify it passes, then commit.

What is the right task granularity for an implementation plan?

A task is the smallest unit that carries its own test cycle and deserves a fresh reviewer's attention. Fold setup and scaffolding into the task that needs them, and only split where a reviewer might reject one task while approving its neighbor.

Can AI agents execute plans written with this approach?

Yes. Plans are saved to docs/superpowers/plans/ and support two execution modes: subagent-driven development with per-task review, or inline execution with batched checkpoints. The plan header declares the required execution sub-skill.

Why should implementation plans avoid placeholder steps?

Placeholders like "add error handling" or "TODO" force the executing engineer to make undocumented design decisions, causing inconsistency and stalls. Every step must contain the actual code, test, or command so the plan is executable without improvisation.

When should a specification be split into multiple plans?

Split when the spec covers multiple independent subsystems. Each plan should independently produce working, testable software, so one plan per subsystem keeps scope reviewable and deliverables coherent.