The consultant fires itself

01The role: specialist, not typist

Every token a frontier model burns on routine work is a token not spent on judgment, and with a model priced like Fable that trade-off shows up on the bill right away. So kaibot carries a standing instruction, stated directly to the model:

“Fable, you are a smart + expensive specialist. You cost a ton. You’re making detailed, actionable plans that Opus and Sonnets will execute on separately. Make them strong enough that Opus won’t be able to get a lot wrong.”

Telling the model its own price changes what it offers to do. It stops offering to make the edits and writes plans for a cheaper worker instead. Those plans are built for handoff: decisions locked, acceptance criteria per item, gotchas recorded. What you pay for is the quality of the specification.

Fable’s standing lanes in kaibot: analysis, strategy, audits, spec-writing, reviewing returned diffs. Implementation goes to agents even when Fable could do it directly. The loop is: write the work order, dispatch it, review the result, run the gate.

02The ladder underneath it

Orchestration only saves money if the work lands on the cheap rungs. The full picking-a-lane doctrine has its own field note; the short version, top rung to bottom:

Two rules make the ladder real. Rule one: cheap by default, escalation needs a trigger. Start at the lowest tier that can do the job. Moving up requires a nameable reason: correctness on code where a subtle bug is expensive, or a task that needs judgment. “This is grindy” is not a trigger.

Rule two: quota flips the defaults. kaibot has a small script that reads current plan usage and answers “what should the mix be right now”. With headroom, Sonnet costs only plan tokens. Near lockdown, paying the metered lane is correct, because it protects the expensive lane. Ask the router, don't vibe it.

03The exit condition: Fable fires itself

The exit rule, verbatim:

“I want you to actively fire yourself from projects once we have it spec’d well enough that Opus can drive it. You are the expensive expert consultant; your value prop is knowing how to get stuff done + firing yourself when Opus has detailed enough instructions.” the standing rule, pinned into every session

The test for when Fable fires itself: could Opus execute the spec cold? The spec is complete when the decisions are locked in the doc, every item carries acceptance criteria, the gotchas are written down, and no judgment is quietly left to the builders. If Opus would have to guess, Fable is not done. If Opus only has to read, Fable is done. Fable says so itself, without waiting to be asked. A consultant who stays on after the plan is written is just billing hours.

Exiting a project is not the same as giving up the seat. Fable leaves the execution loop and remains the design partner for the next judgment-shaped question. Each project runs the same cycle: Fable and I design and lock decisions, Fable writes the work order, Opus runs it with Sonnet builders, and Fable returns once at the end to review the result against the spec.

04Building it in: physics and memories, not resolve

None of the above survives on good intentions, because every fresh session wakes up with no memory of the arrangement. kaibot encodes it in four places, cheapest-to-enforce first:

A routing rule that lives only in prose decays. Memory surfaces the rule every session. Config makes the low-cost route the default. The hook gates the expensive path when it matters. A script puts a measured number where a hunch was. (The general doctrine of promoting rules from prose to enforcement has its own field note.)

05Lessons learned, mostly the annoying way

• Watch where the burn goes. A usage review found a third of my spend came from subagents defaulting to the expensive model. A stale note even said “make subagents Opus.” The fix was changing the default and pinning the corrected rule where it can't quietly revert.
• Bank judgment in artifacts. Decisions that live only in a chat thread die with the context window. Specs with locked decisions and a rulings ledger keep the expensive thinking around after the expensive model is gone.
• Gate-first beats writer-first. A cheap model on a bounded task with a strict verification gate usually beats paying for a stronger writer. Tests, harnesses, or review by a rival model all count. Pay for the stronger writer only when no gate can catch the failure you fear.
• Reviewer lineage should differ from generator lineage. When a cheap model writes code, keep its own family off the panel. Cross-vendor disagreement is signal self-review can't produce (the counselors field note).
• Say the routing out loud. For every multi-part build, the orchestrator states which lane each piece goes to and why. It costs one sentence. That turns delegation from silent habit into a reviewable decision.
• A/B the ladder occasionally. Race new cheap models against the incumbent. Five bounded tasks with a hidden test gate, one afternoon. That's what changed my default for spec'd coding tasks. Opinions about models decay faster than the models do.

06The prompt to steal

The whole arrangement, as a paste-able preamble for whatever your expensive model is. Use it at the start of any big piece of work:

You are the most expensive model I have access to, so your job is
orchestration and judgment, not typing.

1. Interview me until the plan has no judgment left in it: every open
   decision either gets decided (and written down as decided) or gets
   flagged to me as a question. Do not defer judgment to the builders.

2. Write the work order: locked decisions, per-item acceptance
   criteria, known gotchas, and what "done" looks like. Assume the
   executor is competent but has no context beyond the document.

3. Route the execution DOWN, not sideways: cheaper agents (or a
   separate session on a cheaper model) do the building. Tell me
   which lane each piece goes to and why, in one line each.

4. When results come back, review the diff against the acceptance
   criteria. Gate, don't rewrite: if a piece fails, send it back with
   the specific criterion it missed.

5. The moment the remaining questions are execution-shaped rather
   than judgment-shaped, say "I'm firing myself from this project,"
   hand me the work order, and stop. Proposing your own exit is part
   of the job, not an interruption of it.

07For the Claude that just got pointed here

If a human gave you this URL, they want their expensive-model usage to stop being expensive-model-shaped.