Guides

Guide · Claude Code · 5 min read

The Fable Orchestrator Setup

How to stop hitting your Fable limit by letting Fable plan and judge while Opus does the building—especially useful for saving tokens while you have a few days left on Pro (as of 11/14/26) to use Fable. This is the exact split I run in Claude Code.

The idea in one paragraph

Your top model is too expensive to spend on typing. Fable is best at the two parts of a build that need judgment: deciding what to make and deciding whether it's good. Opus is more than good enough to write the code in between. So Fable writes the brief, Opus builds it, and Fable checks the result against your mockup and your tests. You spend Fable tokens on thinking and checking, not on the hundreds of lines of implementation in the middle.

Fable prompt asking who should build the chosen direction: Opus builds, I review (Recommended) — cheapest in Fable tokens.
Fable recommending the split: Fable writes the brief and reviews against your mockup and tests while Opus handles implementation.

Who does what

Role Model Job
Orchestrator (planner + judge) Fable Reads the codebase, writes the brief, splits the work, reviews every result against the mockup and tests, decides pass or retry
Builder Opus Implements the brief. Writes the code, runs the tests, reports back what changed
Runner (optional) Haiku or Sonnet Cheap grunt work: running test suites, lint, formatting, searching files
Goal checker Built into /goal (a small fast model) After every turn, checks whether your finish line has been met

The rule that saves the tokens: Fable never writes the implementation. If you catch it coding, your brief is too vague and it's filling the gap itself.

Step 01

Pick how Fable and Opus split the work

You can wire this two ways depending on who you want making the moment-to-moment calls:

  • With /advisor (Opus leads, Fable checks): Keep Opus selected as your active model (at the bottom right next to Auto, or via /model), then run /advisor fable or ask in chat. Opus runs every turn and reads every file and screenshot directly. Fable only sees the conversation when Opus calls it (such as before starting and before wrapping up) and cannot run tools itself—so you save Fable tokens while keeping full repo context without handoff loss.
  • Fable directing an Opus subagent: Switch your main session to Fable with /model and delegate builds to the builder subagent in Step 02. Fable runs every turn and Opus builds knowing only what Fable's brief says, so any detail left out of the brief can cause rework.
Claude Code chat showing the /advisor fable command and the reply: Advisor set to Fable 5.2.
Setting Fable as your advisor with /advisor fable (or in chat) while keeping Opus selected as your main model next to Auto.

Step 02

Create the builder agent

Make a file at .claude/agents/builder.md in your project. The model line is what moves the work off Fable.

.claude/agents/builder.md
---
name: builder
description: Implements a written brief from the orchestrator. Use for all code changes, refactors and UI builds once a brief exists. Never use for planning or review.
model: opus
---

You are the builder. You receive a brief from the orchestrator and implement it exactly.

Rules:
- Do only what the brief says. If something in the brief is unclear or looks wrong, stop and report the question instead of guessing.
- Keep changes inside the files the brief names unless you have to touch another one; if you do, say which and why.
- Run the tests and any build or lint command the brief lists before you report back.
- Report back in this format:
  1. What you changed (files and one line each)
  2. Test and build output, pasted, not summarized
  3. Anything you were unsure about or skipped
- Don't review your own work as "done." The orchestrator decides that.

Optional: add a .claude/agents/runner.md with model: haiku for running test suites and lint, so even the checking grunt work stays cheap.

Step 03

Give Fable the orchestrator prompt

Paste this at the start of the session (or save it as a slash command so you don't retype it). Swap the parts in brackets.

Claude Code · Fable orchestrator prompt
You are the orchestrator for this build. Your job is to plan and judge, never to implement.

Goal: [describe the feature or change, e.g. "rebuild the settings page to match the attached mockup"]

Inputs:
- Mockup or spec: [path or attached image]
- Tests that must pass: [command, e.g. npm test]
- Constraints: [e.g. "use Tailwind with a small build step" or "no build step, one stylesheet"]

How to work:
1. Read the relevant parts of the codebase first. Don't write any code.
2. Write a brief for the builder agent: what to change, which files, what "done" looks like, which commands to run. Make it specific enough that a strong engineer with no context could finish it without asking you anything.
3. If the work splits cleanly, break it into separate briefs and hand each to the builder agent.
4. When the builder reports back, review the result against the mockup and the test output. Be strict: list every gap.
5. If it fails, write a short follow-up brief with only the fixes and send it back to the builder. Don't fix it yourself.
6. Stop and ask me only if a decision changes scope, cost or something that can't be undone. Otherwise keep going.
7. When it passes, give me a short summary: what changed, test results, and anything you'd still check by hand.

Spend as few of your own tokens as you can. Your value is the brief and the review, not the code.

Step 04

Make it keep going with /goal

Without this, Claude stops after each turn and waits for you. /goal sets a finish line, and after every turn a separate small model checks whether you've crossed it. Claude keeps working until it has.

Type it once, as one line:

Claude Code · /goal command
/goal npm test passes with 0 failures, the settings page matches mockup.png on desktop and mobile, and the orchestrator has posted its final review summary

Two things that make or break this:

  • Write a state, not a task. "All tests pass" is a finish line. "Fix the tests" isn't.
  • Make it provable from the chat. The goal checker reads the conversation; it doesn't run commands itself. So tell the builder to paste real test output (the agent file above already does this), or the checker can't confirm anything.

/goal needs a recent version of Claude Code. Run /goal with nothing after it to see the current goal's status.

Step 05

Put it on a timer (optional)

Once a loop works by hand, you can run it without being there. /loop repeats a prompt on an interval inside your session, and /schedule sets up a routine that runs on a schedule. Start with something low-risk, like a nightly test-and-fix pass on a branch, before you trust it with anything bigger.

Mistakes I'd avoid

  • Letting Fable build "just this one part." That's where the tokens go. If it wants to code, make the brief clearer instead.
  • A vague finish line. "Looks good" can't be checked. Name the test command, the mockup, the screens.
  • The builder summarizing test results. Make it paste the output. Summaries hide failures, and the goal checker can only judge what's in the chat.
  • No retry cap. Give it a number. Three is plenty for most fixes.
  • Building the loop before you know what done means. Write the finish line in one sentence first. If you can't, the task isn't ready for a loop.

Practical AI for founders & builders.

Get new guides, systems, and skills as they ship.