Dev & Engineering workflowplanningsuperpowers

Writing Plans

Breaks requirements into 2-5-minute tasks an implementer with zero codebase context could follow verbatim — bans placeholders like "TBD" or "fill in details"

FollowSkills review · FSRS-1.0
Use with care
63/ 100
Utility16 / 20

The skill clearly targets engineers or coding agents handling a multi-step implementation from an existing specification or requirements. It offers substantial task value through file mapping, decomposition, interfaces, test steps, and commit steps. It also sets boundaries such as splitting independent subsystems and avoiding YAGNI, but it does not define when the skill should not be used, or how to handle non-software work or trivial changes, so the score is conservative.

Reliability13 / 20

The guidance is relatively specific and reproducible: it defines a plan path convention, task granularity, exact file paths, a TDD loop, expected test results, and a self-review checklist. Reliability is limited by assumptions about the codebase, test framework, and agent capabilities, plus dependencies on other skills such as using-git-worktrees, executing-plans, or subagent-driven-development. It lacks recovery guidance for failures, merge conflicts, or inability to save a plan, and there is no skill-specific behavioral test evidence.

Safety15 / 25

The skill primarily produces implementation plans and shows no malware, credential theft, covert exfiltration, or other red-line behavior. Testing, review, user choice of execution mode, and avoidance of unilateral restructuring reduce risk. However, it directs agents to save files, make frequent commits, and potentially include exact git commit steps without an explicit pre-commit consent gate, rollback procedure, sensitive-data handling rule, or escalation condition for high-risk changes. The skill does not define boundaries for network, credentials, or production environments.

Evidence7 / 15

The skill provides good traceability for its intended output through required structure, task interfaces, test commands, expected results, and self-review steps. It also explicitly requires checking specification coverage and scanning for placeholders. The evidence is still mostly prescriptive text: there are no execution records, dedicated tests, evaluation results, or independent corroboration for this SKILL.md. Repository test files do not establish that the selected skill itself was tested, so they cannot support independent verification.

Usability7 / 10

Trigger conditions, the required opening announcement, default save location, plan header, task template, and execution handoff are clear enough to guide plan creation. Missing elements include a minimal input example, compatibility guidance across languages and project types, alternatives when the stated test tooling is unavailable, cost expectations, and explicit exit criteria. It documents that user preferences override the default path, but troubleshooting and other configuration guidance are limited.

Maintenance5 / 10

The repository supplies MIT license information, version metadata, and community issue channels, but these are repository-level signals and do not establish the selected skill's own versioning, changelog, ownership, release responsibility, or update path. The publisher is not verified by the FollowSkills curated enterprise registry, so identity is treated as unknown; no brand-based points are awarded and no deduction is applied for that fact alone. The skill has only name and description metadata, with no version, compatibility, or maintenance information.

Evidence confidence:Low Reviewed Jul 15, 2026 Reviewed revision d884ae04edeb
Before you use it
  • Before executing file-writing or git-commit steps from a plan, obtain explicit user confirmation of scope, target branch, and commit permission; define rollback and pause rules for partial completion or failed tests.
  • Do not treat repository-level tests, README claims, or publisher identity as evidence that this SKILL.md was executed or validated; add skill-specific behavioral or static evaluations.
  • Verify the target project's actual test commands, directory layout, and toolchain before use. If exact code or test expectations cannot be established, pause for context instead of generating placeholders.
  • Add sensitive-data review and human approval for tasks involving credentials, personal data, production configuration, or operations on external systems.
Review evidence [1][2][3][4][5][6][7][8]
See the full review method →

What it does & when to use it

Turns an approved design or requirement into an implementation plan detailed enough for an engineer with zero context on the codebase or domain, and average taste, to execute. Every task must specify exact file paths, complete code, and test steps; the doc explicitly bans placeholder patterns ("TBD", "add appropriate error handling", "similar to Task N"). After writing the plan, it requires a self-review against the original requirement — checking coverage, scanning for placeholders, and confirming type/signature consistency across tasks.

Starts with file-structure planning: which files get created or modified, each with a single clear responsibility, files that change together grouped together. Task granularity: a task is the smallest unit that carries its own full test cycle and is worth a fresh review gate. Every plan must open with a fixed header — goal, architecture, tech stack, and global constraints copied verbatim from the requirement, not paraphrased. Each task specifies exactly which files to create/modify (with line numbers), which upstream interfaces it consumes, which interfaces it produces for downstream tasks, and steps that are each a 2-5-minute concrete action (write the test → run it, confirm failure → write minimal implementation → run it, confirm pass → commit), with complete code in every code block, not description. After writing, self-reviews for requirement coverage, placeholder scan, and cross-task type consistency. Finally offers the user a choice between two execution paths — subagent-driven-development or executing-plans.

  1. A design from the brainstorming stage is approved and needs converting into an executable plan with minute-level task granularity
  2. A task was written as "follow the approach from Task 3" instead of repeating the code — per the SKILL.md rule this is a plan failure that requires filling in
  3. After the plan is written, a self-review against the original requirement finds a requirement with no corresponding task — it gets added rather than discovered as a gap during execution

Pros & cons

Pros
  • Explicitly lists banned placeholder patterns (TBD, add appropriate validation, similar to Task N) and explains why — an implementer might be an isolated agent reading tasks out of order, so "see Task N" carries no information for it
  • The task template requires "interfaces consumed / interfaces produced" fields, forcing cross-task interface consistency to be handled while writing the plan instead of discovered as a type mismatch during execution
  • The plan header requires constraints to be copied verbatim rather than paraphrased, reducing the risk of losing exact values or format requirements in translation
Limitations
  • Only reliably self-enforcing on harnesses that actually read and follow SKILL.md instructions (Claude Code, Codex CLI, etc.) — in a plain chat interface it's just a document a human has to apply by hand.
  • Requiring complete code rather than description at every step makes plan documents long — potentially overkill for genuinely simple requirements
  • Plan quality depends heavily on how complete the upstream brainstorming-stage design is — if the design itself has gaps, this skill doesn't fill in domain knowledge, it faithfully turns the gap into a gap in the plan

How to install

Installed as part of the obra/superpowers plugin — individual skills can't be installed standalone:

  1. Claude Code: official marketplace /plugin install superpowers@claude-plugins-official; or register the community marketplace with /plugin marketplace add obra/superpowers-marketplace then /plugin install superpowers@superpowers-marketplace
  2. Also supports Antigravity, Codex App/CLI, Cursor, Factory Droid, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi — see the repo README for the exact command per harness

Once installed, this skill activates alongside the other 13 Superpowers skills, auto-triggered by using-superpowers based on context — there's no separate invocation step.

How to use

Triggers automatically once a design is approved during brainstorming, converting it into a structured task list. After the plan is written, it offers the user a choice between subagent-driven-development and executing-plans for execution.

Compared to similar skills

Compared to a coarse-grained task list (items like "implement user auth" or "add the frontend page"), the plans this skill produces are granular down to "write this test code, run this command, expect this output" — in principle sharply reducing how much an implementer (especially an isolated subagent) has to fill in on its own, and therefore how much room there is for misunderstanding.

FAQ

Why can't a task say "handle this the same way as Task 3"?
The SKILL.md points out an implementer might read tasks out of order, so "similar to Task N" carries no useful information — the code must be repeated in full so each task is independently readable.

More skills from this repository

All from obra/superpowers

Dev & Engineering

Test-Driven Development (TDD)

Iron rule: no production code without a failing test written first — code written out of order gets deleted and restarted, no "tests added after"

Dev & Engineering

Brainstorming (Requirements & Design)

Forces requirement clarification before any code gets written — hard-blocks implementation until a design is approved

Dev & Engineering

Verification Before Completion

No claim of "done" or "tests pass" without fresh evidence from actually running the check — including hedges like "should" or "looks like"

Dev & Engineering

Finishing a Development Branch

Verifies tests pass, then walks you through a fixed merge/PR/keep/discard menu and cleans up worktrees by strict ownership rules

Dev & Engineering

Receiving Code Review

Bans performative agreement like "you're absolutely right!" — requires verifying feedback before implementing or pushing back

Dev & Engineering

Requesting Code Review

Dispatches a reviewer subagent with isolated context to check your changes, instead of self-grading in the same session that wrote them

Dev & Engineering

Systematic Debugging

Requires completing root-cause investigation before proposing any fix — explicitly bans "just try changing this and see"

Dev & Engineering

Subagent-Driven Development

Dispatches a fresh implementer subagent per task in the same session, with two-stage review and a progress ledger that survives context compaction

Dev & Engineering

Executing Plans

Batch-executes an already-written implementation plan with human checkpoints, for sessions without subagent support

Dev & Engineering

Using Git Worktrees

Prefer the platform's native isolation tool before starting new feature work; fall back to manual git worktrees only when no native tool exists

Dev & Engineering

Dispatching Parallel Agents

Fan out 2+ genuinely independent tasks to parallel subagents in one shot instead of queuing them sequentially

Dev & Engineering

Writing Skills (Authoring & Testing Skills)

Applies TDD's red-green-refactor to writing skill documentation itself — expose real failure modes with a no-skill baseline test first, then write targeted guidance instead of guessing

Dev & Engineering

Using Superpowers (Bootstrap)

The entry-point skill for the whole Superpowers system — mandates invoking a relevant skill whenever there's even a 1% chance it applies

Related skills