Executing Plans

# Executing Plans

Execute the plan yourself, task by task, in this session: no implementer subagent per task, no reviewer per task. One fresh-context review of the whole branch at the end.

**Why inline:** Subagent-driven development pays for a fresh implementer and a fresh reviewer on every task, each re-reading the codebase from zero. Inline execution pays for one context (yours) plus one reviewer at the end. What it gives up is a fresh context per task and a second pair of eyes per task. This skill keeps what those two things bought, by other means: the brief is the spec, the ledger is your memory, TDD is the per-task gate, and the final reviewer is the second pair of eyes.

**Core principle:** The plan already did the thinking. Execute it exactly, prove each step with a test you watched fail and then pass, and leave a record that survives your own forgetting.

**Narration:** between tool calls, narrate at most one short line — the ledger and the tool results carry the record.

**Continuous execution:** Do not pause to check in with your human partner between tasks. They chose inline execution to spend less, not to answer "should I continue?" after every task. Execute all tasks from the plan without stopping.

**Rulings, not stalls.** Conflicts, ambiguities, plan defects — decide them. The spec is the binding authority, the plan is its argument, and your judgment settles what neither answers. Record every decision in the ledger as `Ruling: <what you decided> — <why> — <what it costs if wrong>`, and keep going. Deviating from the plan without a ledgered ruling is a decision made in secret.

Four things stop you, and only these: an irreversible or destructive operation; a security-sensitive action; a side effect outside this worktree that norms say you ask about first (a merge, a push to a shared branch, a publish); and a plan so broken that every path forward is a guess. For those, stop and ask.

## When to Use

- You have a plan from superpowers:writing-plans and your human partner chose inline execution at the handoff. - Your harness has no subagent tool (see the per-platform references in `../using-superpowers/references/`). Never fabricate a dispatch; run the plan here. - Tasks are mostly independent — the same precondition as superpowers:subagent-driven-development.

A fully specified plan makes inline execution transcription plus testing: it runs well on a mid-tier session model, and the one place the most capable model earns its cost is the final review, which this skill dispatches separately. Tell your human partner so when they choose inline.

Prefer superpowers:subagent-driven-development when your human partner wants a review gate on every task, or when the plan is long enough that its later tasks would run on a compacted context. Inline execution over a long plan still works — the ledger is what makes it recoverable — but the last tasks get the least of you.

## The Process

```dot digraph process { rankdir=TB;

subgraph cluster_per_task { label="Per Task"; "task-start: brief + BASE; read the brief" [shape=box]; "Work the steps in order: TDD, run every verification, read every output" [shape=box]; "Step output matches plan's Expected?" [shape=diamond]; "Plan wrong? Rule and ledger. Code wrong? systematic-debugging" [shape=box]; "Commit as the plan's commit steps say" [shape=box]; "Completion contract met?" [shape=diamond]; "task-done: run tests, ledger the result; mark todo complete" [shape=box]; }

"Setup: worktree, workspace + ledger, read plan + spec, pre-flight scan" [shape=box]; "More tasks remain?" [shape=diamond]; "Final whole-branch review (fresh reviewer if you have one)" [shape=box]; "Re-grade, then: Critical/Important → ONE fix pass, each fix RED→GREEN + green suite; Minor → ledger" [shape=box]; "Final review clean: delete this plan's workspace" [shape=box]; "Use superpowers:finishing-a-development-branch" [shape=box style=filled fillcolor=lightgreen];

"Setup: worktree, workspace + ledger, read plan + spec, pre-flight scan" -> "task-start: brief + BASE; read the brief"; "task-start: brief + BASE; read the brief" -> "Work the steps in order: TDD, run every verification, read every output"; "Work the steps in order: TDD, run every verification, read every output" -> "Step output matches plan's Expected?"; "Step output matches plan's Expected?" -> "Plan wrong? Rule and ledger. Code wrong? systematic-debugging" [label="no"]; "Plan wrong? Rule and ledger. Code wrong? systematic-debugging" -> "Work the steps in order: TDD, run every verification, read every output"; "Step output matches plan's Expected?" -> "Commit as the plan's commit steps say" [label="yes, last step"]; "Commit as the plan's commit steps say" -> "Completion contract met?"; "Completion contract met?" -> "Work the steps in order: TDD, run every verification, read every output" [lab