writing-plans

Generates detailed multi-task implementation plans from specs with TDD steps and exact file paths.

1|Updated Apr 3, 2026
One-click install
npx skills add https://github.com/Pgooone/oh-pgone-claudecode --skill writing-plans-pgooone
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/Pgooone/oh-pgone-claudecode/tree/main/.claude/plugins/cache/superpowers-marketplace/superpowers/5.0.6/skills/writing-plans
Command: npx skills add https://github.com/Pgooone/oh-pgone-claudecode --skill writing-plans-pgooone

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a spec or requirements document into an actionable implementation plan is error-prone: engineers get vague tasks, missing file paths, and placeholder steps that stall progress. This Skill produces a complete, bite-sized task plan that an engineer with zero codebase context can execute directly. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into 2-5 minute steps following TDD (failing test, minimal implementation, verify, commit) with exact file paths and commands. - No-Placeholder Enforcement: Requires complete code in every step and includes a self-review checklist covering spec coverage, placeholder scans, and type consistency. - Execution Handoff: Saves plans to docs/superpowers/plans/ and offers subagent-driven or inline execution workflows. - Use Case: After brainstorming a feature spec, invoke this Skill to produce a dated plan document with checkbox-tracked tasks that a subagent can implement task-by-task. ## Quick Start Ask the AI to use the writing-plans skill to create an implementation plan from your spec before writing any code.

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 spec before coding?▼

Invoke the writing-plans skill with your spec or requirements. It maps out the file structure first, then decomposes the work into tasks with exact file paths, failing tests, minimal implementations, and commit steps saved to docs/superpowers/plans/.

What granularity should tasks have in an implementation plan?▼

Each step should be one action taking 2-5 minutes: write the failing test, run it to confirm failure, implement minimal code, run tests to confirm pass, then commit. This keeps progress trackable with checkbox syntax.

Can the plan be executed by subagents after it is written?▼

Yes. After saving the plan, you choose between subagent-driven development, which dispatches a fresh subagent per task with review between tasks, or inline execution with batch checkpoints using the executing-plans skill.

What are common mistakes when writing implementation plans?▼

Common failures include placeholders like TODO or 'add error handling', missing exact file paths, steps without actual code, and inconsistent type or method names across tasks. The skill's self-review checklist catches spec gaps, placeholders, and type mismatches.

When should a spec be split into multiple implementation plans?▼

Split when the spec covers multiple independent subsystems. Each plan should produce working, testable software on its own, so one plan per subsystem keeps scope manageable and independently executable.