A viral Claude Code setup says Fable 5.1 grades /goal. Claude Code actually uses a small fast model

Claude Code /goal grades every turn with your configured small fast model, and a viral setup that puts Fable 5.1 in that seat gets the mechanism half right. That is what Anthropic's Claude Code documentation says as of October 7, 2026. The setup tip that spread this week also ships a launch command that Claude Code 2.1.292 rejects outright.

The tip's architecture looks reasonable on paper. Opus 5.5 runs the main session at high effort. Three Sonnet 5.5 subagents handle editing, code exploration and test runs. Fable 5.1 sits "on call" as the Stop hook evaluator. And TypeSafe's Jev model supposedly resolves small forks, such as which file, which tool, retry or halt, in under 16 ms. It ends with a paste-in prompt that asks Claude Code to reconfigure itself around that tree.

I checked each line against the docs. The description of how /goal evaluates a turn is accurate. The grader model, the launch flag and the Jev claim are wrong. Paste it as written and you get a command that exits with an error, plus a Fable grader that was never wired up.

/goal runs a small-model check after every turn

/goal sets a completion condition and keeps Claude working, turn after turn, until the condition holds. The /goal documentation page describes it as "a wrapper around a session-scoped prompt-based Stop hook". Each time Claude finishes a turn, Claude Code sends the condition and the conversation so far to the small fast model. That model returns one of three verdicts with a short reason.

Verdict	What Claude Code does
Not yet met	Claude keeps working and uses the reason as guidance for the next turn
Met	Claude Code clears the goal and records an achieved entry
Impossible	Claude Code clears the goal and records a failed entry with the reason

The evaluator does not call tools. It can't run your tests or open your files, so it judges only what Claude has already put into the conversation. Write the condition as something Claude's own output can prove. "All tests in test/auth pass" works because the test output lands in the transcript. Conditions can run up to 4,000 characters.

The tip lists "defer goal checks while background tasks run" as a setup step. That behavior is already the default. If a subagent or background shell command is still running when a turn ends, Claude Code skips that evaluation and waits for a turn with nothing in flight. After 30 minutes of waiting, Claude Code runs a check-in, then backs off to twice the interval, capped at four times the first. Only the interval is tunable, through CLAUDE_CODE_GOAL_CHECKIN_MINUTES, and 0 turns off check-ins and automatic retries together.

Pairing /goal with auto mode is also correct. The docs put it plainly: auto mode removes per-tool prompts, and /goal removes per-turn prompts. A goal never changes your permission mode, so unattended runs need auto mode.

The grader, the flag and the Jev numbers don't match the docs

The tip says	The docs say	What happens if you paste it
Fable 5.1 grades /goal	/goal takes no model argument; the small fast model grades unless you set ANTHROPIC_DEFAULT_HAIKU_MODEL	Without that variable, Fable never grades. With it, every background call moves too
claude --auto-mode "/goal ..."	No such flag exists; --enable-auto-mode was removed in v2.1.111 in favor of --permission-mode auto	Claude Code 2.1.292 prints error: unknown option '--auto-mode' and exits with code 1
Defer goal checks during background work	Built-in behavior; only the check-in interval is configurable	A config step for a setting that does not exist
Jev routes micro-forks in under 16 ms	TypeSafe reports 70 to 500 ms end to end, with most queries near 100 ms	No documented integration, and even the 70 ms floor is more than four times the claim

I ran the tip's claude --auto-mode command on Claude Code 2.1.292 on October 7, 2026. It failed before the session started. The CLI reference lists --enable-auto-mode as removed and points to --permission-mode auto instead. The auto-mode name survives only as a subcommand that prints or resets classifier rules. On v2.1.283 or later, auto mode is already the built-in starting mode for interactive terminal sessions, according to the permission modes guide.

Jev is the biggest stretch. TypeSafe's launch post for Jev gives an end-to-end response time of 70 to 500 ms. Its docs say most queries finish in about 100 ms, and one cookbook run measured a 114 ms mean round trip. No 16 ms figure appears anywhere in TypeSafe's full documentation. The bigger problem is fit. TypeSafe's guide for coding-agent users says Jev "is not a drop-in replacement for the LLM behind Claude Code" or similar tools. You use your agent to write software that calls Jev. Neither Anthropic nor TypeSafe documents a hook that hands Claude Code's tool selection or retries to Jev. You could build one with a command hook, but nobody has published latency numbers for it.

Three smaller gaps cost money or time if you copy them:

• /goal has no built-in turn cap. The docs suggest adding a clause such as "or stop after 20 turns" to the condition. Claude Code also stops the loop when Claude answers the evaluator for several turns without using a tool.
• The built-in Explore subagent runs on the main conversation's model, so under Opus 5.5 it runs Opus 5.5. Setting CLAUDE_CODE_SUBAGENT_MODEL alone does not move Explore or Plan. A Sonnet explorer needs your own subagent named Explore.
• Opus 5.5 defaults to medium effort. The model configuration docs report that in Anthropic's testing, Opus 5.5 at medium matches or beats Opus 5 at high on coding and knowledge work. When you move from Opus 5, Anthropic suggests starting Opus 5.5 at medium.

Making Fable the grader reroutes every background call

If you still want Fable 5.1 deciding when work is done, the docs offer two routes. Both carry costs the tip skips.

The first is the environment variable the /goal page names. Its warning is blunt: Claude Code reads ANTHROPIC_DEFAULT_HAIKU_MODEL everywhere it uses the small fast model. Setting it also resolves the haiku alias to your model and runs background work, such as conversation summarization, on it.

# Not recommended: this moves every small-fast-model job, including the haiku alias
# and conversation summarization, onto Fable 5.1
export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-fable-5-1

The bill moves with it. The docs describe evaluation tokens on the small fast model as "typically negligible compared to main-turn spend." On Fable, every verdict and every background job bills at Fable rates instead. Depending on plan, Fable usage can draw on usage credits. Interactive sessions ask for consent first. Runs started with -p never ask and bill the credits directly.

The second route is a hand-written prompt-based Stop hook with its own model field. The hooks reference documents that field and says it defaults to the background-functionality model. Only this hook moves to Fable.

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "model": "claude-fable-5-1",
            "prompt": "Decide whether Claude may stop: $ARGUMENTS. Return {\"ok\": true} only if the last reply shows npm test and npm run lint both exiting with code 0. Otherwise return {\"ok\": false, \"reason\": \"what to do next\"}. If the condition can never be met, also include \"impossible\": true."
          }
        ]
      }
    ]
  }
}

That hook behaves differently from /goal in three ways. It lives in a settings file, so it fires in every session in that scope. Its input is the hook JSON, which for Stop includes last_assistant_message, transcript_path and a list of background tasks. The docs never say it receives the full conversation, and a prompt hook can't call a tool to open the transcript file. It also runs under limits: a 30-second default timeout, and a cap of eight consecutive continuations without a tool call, adjustable through CLAUDE_CODE_STOP_HOOK_BLOCK_CAP.

An agent-type hook can read files with Read, Grep and Glob for up to 50 turns, with a 60-second default timeout. The docs label agent hooks experimental, and they ignore the impossible verdict.

My take: a condition like "tests and lint pass" needs a grader that can read two exit codes. A small model does that fine. Paying Fable rates on every turn to read a zero buys nothing. Fable earns its price on judgment calls in the middle of the work.

/advisor is the documented way to keep Fable on call

What the tip wants, Opus writing code while Fable stands by, already exists as the advisor tool. Turn it on with /advisor fable in a session, the advisorModel setting, or claude --advisor fable at launch. The advisor pairing table accepts Fable or Opus 5 and later as advisors when Opus 5.5 is the main model.

We covered the details in Claude Code lets Fable 5.1 advise Opus 5.5, but the model decides when to ask. The short version: Opus decides when to consult. Each consultation rereads the whole conversation and bills at the advisor's rates. The feature is experimental and requires the Anthropic API.

Mechanism	When it runs	Model	What it sees	Scope
/goal	After every turn	Small fast model, swappable only globally	The condition and the conversation so far	Current session
/advisor	Mid-task, when the main model asks	The advisor you pick, such as fable	The full conversation, including tool calls and results	Session or user settings
Custom prompt Stop hook	After every turn	Whatever the model field names	The hook input JSON	Every session in the settings scope

The two features cover different moments. /advisor shapes decisions during the work, and /goal decides when the work counts as done. The docs do not say they conflict.

The corrected setup keeps the small grader and moves Fable to /advisor

Here is the viral tree corrected against Claude Code's docs. Jev is gone because there is no documented way to plug it in.

Main session: Opus 5.5 (start at the default medium effort, raise to high only if needed), auto mode
├─ worker: edits and patches code (model: sonnet, effort: medium)
├─ Explore: reads code and finds call sites (custom subagent that overrides the built-in, model: sonnet)
├─ verifier: runs tests and lint, reports commands and exit codes (model: sonnet, effort: medium)
├─ /advisor fable: Fable 5.1 on call, Opus 5.5 decides when to consult
└─ /goal: small fast model grades each turn; the condition includes a 20-turn limit

Put the three subagents in .claude/agents/ as Markdown files with YAML frontmatter. The subagent docs accept sonnet, opus, haiku, fable, a full model ID or inherit for model. The effort field overrides the session level but loses to the CLAUDE_CODE_EFFORT_LEVEL variable.

---
name: worker
description: Edits and patches code according to the plan from the main session
tools: Read, Edit, Write, Bash, Grep, Glob
model: sonnet
effort: medium
---

You edit and patch code. Change only the files the main session names, then list each changed file and why.

---
name: Explore
description: Searches and reads code to find definitions, call sites and related files
tools: Read, Grep, Glob
model: sonnet
effort: medium
---

You read and never write. Report file paths, line numbers and call relationships. Do not propose edits.

---
name: verifier
description: Runs tests and lint and reports the results
tools: Read, Bash, Grep, Glob
model: sonnet
effort: medium
---

You verify and never edit files. Run npm test and npm run lint, and report each command with its exit code verbatim. On failure, include the first error.

On the Anthropic API, the sonnet alias resolves to Sonnet 5.5. On Amazon Bedrock and Google Cloud's Agent Platform it resolves to Sonnet 4.5, and on Claude Platform on AWS to Sonnet 4.6. Teams on those providers get an older Sonnet unless they pin a newer model ID their provider offers.

Launch with --permission-mode auto in place of the flag that does not exist:

# Interactive: auto mode is already the default on v2.1.283+; the flag makes intent explicit
# If your plan bills Fable to usage credits, accept consent via /model fable first; otherwise --advisor fable exits at launch
claude --model opus --permission-mode auto --advisor fable

Then set the goal inside the session. The condition asks Claude to print exit codes because the grader reads only the conversation:

/goal npm test and npm run lint both exit with code 0, and the reply shows both exit codes; no existing file under test/ is modified; or stop after 20 turns

For unattended batch runs, the docs show /goal with -p, and --permission-mode works with -p too:

# Non-interactive: the whole /goal loop runs in one invocation; stream-json prints progress as it goes
claude -p --permission-mode auto --output-format stream-json --verbose \
  "/goal npm test and npm run lint both exit with code 0, and the reply shows both exit codes; or stop after 20 turns"

Two caveats apply. The docs never show /goal as the initial prompt of an interactive session, the claude "/goal ..." form, so typing /goal after launch is the safe path. And -p runs skip the Fable usage-credit prompt, which is why the batch example leaves out --advisor fable.

If you prefer the paste-in approach, here is the same five-step prompt, corrected:

Reconfigure my Claude Code setup around this tree:

1. Run the main session on Opus 5.5, launched with --permission-mode auto. Keep Opus 5.5 at its default medium effort; to raise it to high, use /effort high or modelSettings, never a top-level effortLevel in my user settings file.
2. Keep Fable 5.1 on call as an advisor by setting advisorModel to fable. Leave the /goal grader on the default small fast model and do not set ANTHROPIC_DEFAULT_HAIKU_MODEL. If my account needs Fable billing consent first, tell me to run /model fable instead of handling it.
3. Create worker and verifier subagents in .claude/agents, plus a subagent named Explore that overrides the built-in, all with model: sonnet and effort: medium. Leave any existing subagent with the same name untouched and list it for me. /goal already defers evaluation while background work runs, so add no setting for it.
4. Do not create any hook that routes tool selection, path selection or automatic retries through Jev; neither Claude Code nor TypeSafe documents that integration.
5. Add one rule to CLAUDE.md: run long tasks in auto mode with /goal <criteria>, where the criteria state a check Claude can prove in the conversation and end with "or stop after 20 turns".

Show me every configuration change as a diff first. No edits until I say go.

FAQ

Which model does Claude Code /goal use to judge completion?

Claude Code /goal uses your configured small fast model, the Haiku-class model that also runs background work. The main session model and Fable 5.1 play no part in the verdict. Changing the grader requires ANTHROPIC_DEFAULT_HAIKU_MODEL, which also changes the haiku alias and background tasks such as conversation summarization.

Does the Claude Code /goal evaluator run my tests?

No. The Claude Code /goal evaluator calls no tools, so it never runs commands or reads files. Claude runs the tests, and the evaluator reads the results in the conversation. Write conditions that Claude's printed output can prove, such as exit codes.

Can Claude Code /goal run forever?

Claude Code /goal has no built-in turn limit, so the docs recommend a clause such as "or stop after 20 turns". Claude Code halts the loop when Claude answers the evaluator for several turns without tool use. An authentication failure, an exhausted credit balance, an unrecoverable context overflow or an unavailable model also clears the goal.

Can TypeSafe's Jev act as a router inside Claude Code?

As of October 7, 2026, neither TypeSafe nor Anthropic documents such an integration. TypeSafe states that Jev cannot replace the model behind Claude Code. The only Claude Code tie-in is a TypeSafe skill that helps Claude write code calling Jev, which TypeSafe says answers most queries in about 100 ms.

Sources

• Claude Code Docs: Keep Claude working toward a goal
• Claude Code Docs: Hooks reference
• Claude Code Docs: Create custom subagents
• Claude Code Docs: CLI reference
• Claude Code Docs: Choose a permission mode
• Claude Code Docs: Model configuration
• Claude Code Docs: Escalate hard decisions with the advisor tool
• TypeSafe: Introducing System One models and Jev
• TypeSafe Docs: Coding agents

Author Insight

The viral tree confuses two jobs that Claude Code keeps separate. Deciding whether work is finished is cheap when the finish line is an exit code, and Claude Code treats it that way by handing it to the small fast model. Deciding what to do next is expensive, and that is where Fable belongs. The setup reverses the two, putting the costliest model on the cheapest question. The one case that flips this is a completion condition no exit code can capture, such as a design trade-off. Only there does a Fable-graded Stop hook earn its per-turn cost, and only with the transcript limits above in mind.