task git:20260925.c493c24B

Immutable. This exact content never changes and is served at /api/v1/blob/1f147661fd2491d7.

---
description: >-
  Take a task and decide for yourself whether it needs a plan, write the plan
  when it does, and then decide whether the operator has to look — plan and hand
  off, plan and then implement, or implement with no plan at all. Invoke as
  `/task <what to do>`. The prompt is a conditional go-ahead scoped to that one
  task.
---

The decision this skill makes, before any other: **does this task get a plan, and does the plan block on the operator?** Those are two questions with a plan file between them: the second judges the plan, so it is asked once the plan exists.

**The prompt is a conditional go-ahead.** It authorizes implementation *on condition that* the agent judges the operator's gate unnecessary, scoped to the task in that message and to that message alone.

`/task <what to do>` is the invocation, and it is also where an unrouted session's first change lands: CLAUDE.md § "Plan mode & questions in web sessions" routes here the first turn that asks for a change to this codebase, whether that is the opening prompt or a follow-up to one that was answered, so most tasks arrive without anyone typing the name. A task routed mid-session is the work as the conversation now stands. A `#<N>` in that prompt means the thread is exported and committed before anything else happens — `/take-issue` does that and hands the number back. Both mentions stay bare rather than `@`-references: this skill ships to adopters who track no issues at all, and nothing here needs those files read.

**What that routing costs, plainly:** the agent makes the plan-or-not call on every session that asks for a change, without the operator opting into it. The gate survives that — Step 3 routes gate-worthy work back to `/plan` — but it fires when Step 3's questions say so rather than on every task.

**Anything a caller passes beyond the task — an `<issue>`, an export path — rides through unchanged to whichever outcome runs, and is never read here:** this skill knows what a task is and nothing else, and what the extras mean belongs to the skills at either end of them.

## Step 1 — Does this task get a plan?

Either reason is enough on its own.

**Writing it down would change what you build.** A plan is how an agent gets its own head straight, and that value needs no operator:

- several parts whose order matters, or edits that only make sense landing together;
- a live reuse call — the mandatory `## DRY notes` is the forcing function, and it earns the file whenever "shared or duplicated?" has a real answer to argue;
- a shape you would otherwise discover halfway through, after building the first half against a different one.

The test: if you can hold the whole change in your head and name every file it touches, the file buys nothing.

**Or any of Step 3's four signs is even arguably present.** You are not deciding it yet — that is Step 3's call, made against the plan rather than against the line that asked for the work. Here you only notice that the question is live.

**No to both → `@.claude/skills/go/SKILL.md` § "Planless entry"** with the task, where the diff is the plan.

**This step is deliberately over-inclusive.** Being wrong costs a file `/finalize` sweeps, so a close call writes one.

## Step 2 — Write it as a draft

`@.claude/skills/plan/SKILL.md` Part 1, unchanged: `docs/plans/<slug>.draft.do-not-implement.md`, banner and all, published through `/pr` so the operator has a surface to read and interrupt on.

**Every planning route produces a draft.** It is what a `/handle` reads if this session dies between writing the file and flipping it — a plan awaiting a go-ahead, which costs one round trip to re-give. The alternative, an `*.in-progress.md` claiming a live session holds the plan right now, is a reading someone has to untangle by hand.

It is also what makes a carve safe here. `@.claude/skills/plan/carving.md` files nothing at plan time and leans on the draft being the gate, so a carve found while writing this plan needs no procedure of its own: the file is already a draft carrying its banner, and Step 3 is where it stops.

## Step 3 — Does the operator need to look?

Now the plan exists, so the question is asked against it rather than forecast from the line that asked for the work. Any one of these is a yes:

- **The work costs far more to produce than to describe.** The plan is a page, the work is a day, and a wrong direction is caught for the price of the page.
- **A fork carries no recommendation** — the exception in `@.claude/skills/plan/SKILL.md` Part 2. Guess wrong and most of the work is wasted; the plan is what makes the choice the operator's.
- **A review round comes too late.** The step is irreversible or outward-facing, or later work builds on it before the PR is read.
- **The scope is itself the question** — you would be deciding *what* the task is, not just how to do it. So is a split across sessions, an elephant or a pizza alike (`@.claude/skills/plan/SKILL.md` § "Splitting work across sessions"): the shape is the operator's to pick, so a plan that splits ends here.

None of these asks how important the change is. Importance is why the operator reviews the diff; the gate is for what reviewing a diff cannot undo.

**Yes → end at `@.claude/skills/plan/SKILL.md` § "Handing off"**, and the next session flips the draft.

**No → enter `@.claude/skills/go/SKILL.md` at its Step 1**, which flips the draft in a commit quoting the `/task` prompt as the go-ahead, and carries on into the work. The conditional go-ahead is what that flip records; nothing about it is skipped because the same session wrote the plan.

## The three outcomes

Two of the three are the two ends of one route, forking at Step 3 where the plan exists to fork on.

1. **Plan and hand off** — Step 1 yes, Step 3 yes.
2. **Go** — Step 1 no. The diff is the plan.
3. **Plan, then go** — Step 1 yes, Step 3 no.

**Report the call in the first sentence of the turn, with its reason and the override**: "Doing this directly rather than planning it — *reason*. Say `plan` and I'll write one instead." That costs the operator one word to reverse, and puts the judgment on the record in the turn that acted on it.

**On that override, stop where you are.** Write the plan for the whole task and name the commits that already exist, so the operator reviews it knowing what is built. Leave those commits in place; reverting work nobody asked you to revert costs more than the work does.

**When a call is close the two steps break opposite ways.** A close Step 3 goes to the operator — being wrong toward the gate costs a round trip, being wrong past it costs them reviewing work that should not exist. A close Step 1 writes the file, per above.

**The pull is toward outcome 2**, which starts producing this turn and bills its cost later, to whoever reads the result. Weigh it against that round trip rather than against the appetite to start.