Writing Plans
Turn multi-step software requirements into executable, testable implementation plans.
The evidence scopes the skill to producing an implementation plan from existing requirements and specifies a plan location, worktree context, and execution-choice handoff. No malware, credential handling, or covert exfiltration is visible. Points are deducted because permissions for file writes, commit instructions, and later subagent execution, plus sensitive-data handling, rollback, and confirmation boundaries, are not fully specified.
The evidence provides a structured workflow with scope checks, file mapping, task decomposition, test steps, expected output, and self-review. Points are deducted because it depends on other skills not supplied here and does not define diagnosable behavior for invalid input, save failure, test failure, or unsupported environments. Static review also caps this dimension at 10 without skill-specific execution evidence.
The evidence clearly identifies multi-step requirements as the trigger and defines output structure, storage path, subsystem splitting, and scope checks. Points are deducted because boundaries for non-code work, missing specifications, and testless projects are unclear, and Chinese-language support and cross-harness semantic triggering are not addressed.
The evidence shows good information architecture with overview, scope, file structure, task template, placeholder rules, self-review, and execution handoff. Repository context supplies MIT licensing, a version, installation guidance, and maintenance channels. Points are deducted because the skill has no intrinsic version, changelog, or explicit maintainer/update path, and it relies implicitly on several external subskills.
The evidence requires exact paths, complete code, test commands, expected results, and independently reviewable tasks, which should produce a practically usable plan. Points are deducted because no verified representative output or skill-specific result evidence is included, and quality still depends on the model's interpretation of the specification and codebase. Static review caps this dimension at 7.
The evidence is auditable as text and requires specification coverage, placeholder scanning, and type-consistency checks. Points are deducted because there are no tests covering the writing-plans key paths, no third-party reproduction report, and no corroborating evidence from independent sources; repository tests shown mainly cover other components. Static review caps this dimension at 5.
- The skill depends on subagent-driven-development, executing-plans, and other skills, but does not define safe fallback behavior when they are unavailable.
- The plan format includes file-saving and commit instructions as potential external effects without a detailed confirmation, recovery, or rollback procedure.
- No writing-plans-specific behavioral tests or representative verified plan are supplied, so human review remains necessary.
- Chinese-language behavior and mainland-China environment fit are not specified; the core function does not explicitly depend on an overseas online service.
What does this skill do, and when should you use it?
Writing Plans is intended for multi-step software work with an existing specification or set of requirements, before code is changed. It first maps the files and responsibilities involved, then breaks the work into independently testable tasks that take roughly 2–5 minutes each. Plans include exact paths, complete code examples, test commands, expected results, and Git commit steps, while emphasizing DRY, YAGNI, TDD, and frequent commits. Plans are saved by default to `docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md`, unless the user specifies another location.
Reads the supplied specification or requirements and checks whether they cover multiple independent subsystems; maps files to create or modify and assigns each a responsibility; produces a Markdown implementation plan with a required header, task interfaces, checkbox steps, code blocks, test commands, expected output, and Git commit commands; then performs self-review for specification coverage, placeholders, and type consistency before offering subagent-driven or inline execution options.
- A developer has an approved design and needs a plan that an engineer with little project context can follow.
- A team is implementing a multi-step feature and wants each task to have its own test cycle and review boundary.
- A TDD-oriented engineer needs failing-test, minimal-implementation, passing-test, and commit steps spelled out in order.
- A maintainer wants explicit file ownership and decomposition before changing an existing codebase.
What are this skill's strengths and limitations?
- Requires exact file paths, complete code, and copyable verification commands.
- Uses task boundaries where each task produces an independently testable deliverable.
- Includes self-review for specification coverage, placeholders, and type consistency.
- Explicitly reinforces DRY, YAGNI, TDD, and frequent commits.
- It writes an implementation plan rather than implementing the code changes.
- It assumes the implementer knows little about the codebase, toolset, and problem domain, so plans can be detailed.
- Follow-up implementation relies on execution skills from the wider Superpowers collection.
- The source provides no standalone test suite or cross-platform validation results for this skill.
How do you install this skill?
The skill is located at skills/writing-plans/SKILL.md in the obra/superpowers repository. The README describes Superpowers as a 14-skill collection installed separately for each coding-agent harness; for example, Antigravity uses agy plugin install https://github.com/obra/superpowers, while Pi uses pi install git:github.com/obra/superpowers. Other installation methods depend on the harness. The source does not document a standalone installation procedure for this skill.
How do you use this skill?
Use it when a specification or requirements exist for a multi-step task, before touching code. At the start, announce: I'm using the writing-plans skill to create the implementation plan. Save the completed plan to docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md, unless the user provides a preferred location. Then offer subagent-driven execution or inline execution in the current session.