Plan
Turn a gated spec into milestones and atomic tasks: what ships in what order,
what blocks what, what fails first, and what is explicitly out of scope.
Migrated from .claude/commands/plan.md under ADR-064, which makes skills the
single user-invocable surface.
@CLAUDE.md
Triggers
plan how to build this, break this into milestones, decompose this spec,
plan this work
If you arrived here without a spec, run the front-gate first
Planning a spec that was never gated manufactures work. If there is no /spec
output for this work (no requirement, no design, no testable acceptance
criteria), do not decompose it into milestones yet. Run spec first: it applies
the front gate (the six forcing questions, the front-gate-before-pipeline
pattern) and confirms a named blocked user, a documented status quo, and a
concrete observation before any downstream step runs. Return here once the spec
exists.
Skip this only when the user explicitly asks to plan an ungated idea and accepts
that trade-off.
Plan: $ARGUMENTS
If $ARGUMENTS is empty, check for recent spec output in the conversation. If
none is found, ask what to plan rather than inferring it.
Process
- Read the spec or issue.
- Map sub-problems to existing code. What already exists? Use Grep and Glob to
verify rather than assuming.
Task(subagent_type="milestone-planner"): You are a project planner. Break
the spec into milestones with clear exit criteria. Each milestone is
independently shippable. Sequence by dependencies. Flag parallel
opportunities.
Task(subagent_type="task-decomposer"): You are a work breakdown specialist.
Decompose each milestone into atomic tasks. Each task is independently
verifiable with a clear done definition. Size by complexity (S/M/L), not time.
Skill(skill="execution-plans") to persist the plan as a versioned artifact.
Task(subagent_type="analyst"): You are a risk analyst. Run a pre-mortem on
this plan. What fails first? What dependencies are fragile? What assumptions
are untested?
Task(subagent_type="critic"): You are a plan reviewer. Validate: is scope
complete? Can tasks execute in the stated sequence? Are estimates credible?
Is anything missing?
Evaluation Axes
| Axis |
Question |
| Scope integrity |
Nothing unnecessary, nothing missing |
| Dependency ordering |
Can tasks execute in the stated sequence? |
| Risk coverage |
Does every P0 risk have a mitigation? |
| Estimate confidence |
Complexity-based sizing (S/M/L), never time-based |
| Reversibility |
Which steps are hard to undo? |
Principles
- Programming by Intention. Each task reads like an intent, not an
implementation detail.
- OODA loop. Observe (read the spec), Orient (map to existing code), Decide
(sequence tasks), Act (commit the plan). Faster loops win.
- First principles. Question the requirement, try to delete the step, then
optimize, then speed up, then automate. Never automate something that should
not exist.
Output
| Section |
Contents |
| Milestones |
Numbered, each with exit criteria |
| Tasks per milestone |
Atomic, with acceptance criteria and S/M/L sizing |
| Dependency graph |
What blocks what, what can run in parallel |
| Risk register |
Risk, likelihood, impact, mitigation |
| Deferred items |
Explicitly out of scope for this plan |
Verification
Anti-Patterns
| Avoid |
Why |
Instead |
| Planning an ungated idea |
Produces a credible milestone list for work no user asked for |
Run spec first, or record that the user accepted the trade |
| Time estimates |
Anchor on a number nobody can hold, and rot on contact |
Size by complexity, S/M/L |
| Mapping sub-problems from memory |
Plans a rewrite of code that already exists |
Grep and Glob before claiming something is missing |
| Milestones that ship only together |
Removes the option to stop early, which is the point of a milestone |
Split until each one is independently shippable |
| Silent scope cuts |
The reader cannot tell a decision from an oversight |
List them under Deferred items |
Extension Points
- New evaluation axis. Add a row to the axes table and a matching
Verification checkbox, so the axis is both stated and checked.
- Different persistence. Step 5 delegates to
execution-plans. A project
that tracks plans elsewhere swaps that one call, not the process.
- Parallel decomposition. Steps 3 and 4 run per milestone. For a large spec
they can fan out per milestone rather than running once over all of them.
1---2name: plan3version: 1.0.04description: Decompose a spec into milestones and atomic tasks with dependency ordering, risk register, and complexity sizing. Use when you say `plan how to build this`, `break this into milestones`, or `decompose this spec`, and run it after spec. Do NOT use to decide what to build (use spec), and do NOT use to write the code (use build).5license: MIT6allowed-tools: Task, Skill, Read, Write, Glob, Grep7argument-hint: spec-output-or-issue-number8user-invocable: true9metadata:10 source: https://skillmd.com/skills/rjmurillo/plan11---1213# Plan1415Turn a gated spec into milestones and atomic tasks: what ships in what order,16what blocks what, what fails first, and what is explicitly out of scope.1718Migrated from `.claude/commands/plan.md` under ADR-064, which makes skills the19single user-invocable surface.2021@CLAUDE.md2223## Triggers2425`plan how to build this`, `break this into milestones`, `decompose this spec`,26`plan this work`2728## If you arrived here without a spec, run the front-gate first2930Planning a spec that was never gated manufactures work. If there is no `/spec`31output for this work (no requirement, no design, no testable acceptance32criteria), do not decompose it into milestones yet. Run `spec` first: it applies33the front gate (the six forcing questions, the `front-gate-before-pipeline`34pattern) and confirms a named blocked user, a documented status quo, and a35concrete observation before any downstream step runs. Return here once the spec36exists.3738Skip this only when the user explicitly asks to plan an ungated idea and accepts39that trade-off.4041Plan: $ARGUMENTS4243If `$ARGUMENTS` is empty, check for recent spec output in the conversation. If44none is found, ask what to plan rather than inferring it.4546## Process47481. Read the spec or issue.492. Map sub-problems to existing code. What already exists? Use Grep and Glob to50 verify rather than assuming.513. `Task(subagent_type="milestone-planner")`: You are a project planner. Break52 the spec into milestones with clear exit criteria. Each milestone is53 independently shippable. Sequence by dependencies. Flag parallel54 opportunities.554. `Task(subagent_type="task-decomposer")`: You are a work breakdown specialist.56 Decompose each milestone into atomic tasks. Each task is independently57 verifiable with a clear done definition. Size by complexity (S/M/L), not time.585. `Skill(skill="execution-plans")` to persist the plan as a versioned artifact.596. `Task(subagent_type="analyst")`: You are a risk analyst. Run a pre-mortem on60 this plan. What fails first? What dependencies are fragile? What assumptions61 are untested?627. `Task(subagent_type="critic")`: You are a plan reviewer. Validate: is scope63 complete? Can tasks execute in the stated sequence? Are estimates credible?64 Is anything missing?6566## Evaluation Axes6768| Axis | Question |69|------|----------|70| Scope integrity | Nothing unnecessary, nothing missing |71| Dependency ordering | Can tasks execute in the stated sequence? |72| Risk coverage | Does every P0 risk have a mitigation? |73| Estimate confidence | Complexity-based sizing (S/M/L), never time-based |74| Reversibility | Which steps are hard to undo? |7576## Principles7778- **Programming by Intention.** Each task reads like an intent, not an79 implementation detail.80- **OODA loop.** Observe (read the spec), Orient (map to existing code), Decide81 (sequence tasks), Act (commit the plan). Faster loops win.82- **First principles.** Question the requirement, try to delete the step, then83 optimize, then speed up, then automate. Never automate something that should84 not exist.8586## Output8788| Section | Contents |89|---------|----------|90| Milestones | Numbered, each with exit criteria |91| Tasks per milestone | Atomic, with acceptance criteria and S/M/L sizing |92| Dependency graph | What blocks what, what can run in parallel |93| Risk register | Risk, likelihood, impact, mitigation |94| Deferred items | Explicitly out of scope for this plan |9596## Verification9798- [ ] A spec exists for this work, or the user accepted planning an ungated idea99- [ ] Sub-problems mapped against real code, verified with Grep or Glob100- [ ] Every milestone has exit criteria and is independently shippable101- [ ] Every task has a done definition and an S/M/L size, never a time estimate102- [ ] Plan persisted through `execution-plans`, not left in the conversation103- [ ] Pre-mortem run, and every P0 risk carries a mitigation104- [ ] Deferred items listed explicitly rather than left unstated105106## Anti-Patterns107108| Avoid | Why | Instead |109|-------|-----|---------|110| Planning an ungated idea | Produces a credible milestone list for work no user asked for | Run `spec` first, or record that the user accepted the trade |111| Time estimates | Anchor on a number nobody can hold, and rot on contact | Size by complexity, S/M/L |112| Mapping sub-problems from memory | Plans a rewrite of code that already exists | Grep and Glob before claiming something is missing |113| Milestones that ship only together | Removes the option to stop early, which is the point of a milestone | Split until each one is independently shippable |114| Silent scope cuts | The reader cannot tell a decision from an oversight | List them under Deferred items |115116## Extension Points117118- **New evaluation axis.** Add a row to the axes table and a matching119 Verification checkbox, so the axis is both stated and checked.120- **Different persistence.** Step 5 delegates to `execution-plans`. A project121 that tracks plans elsewhere swaps that one call, not the process.122- **Parallel decomposition.** Steps 3 and 4 run per milestone. For a large spec123 they can fan out per milestone rather than running once over all of them.