How to Use Claude Fable 5.2 in Claude Code

Back
Kevin Riedl

16 min read · 02 Jul 2026
Last reviewed

Next
Made on your device, with no Instagram connection. We copy the post link for Instagram’s Link sticker.

Use Claude Fable 5.2 in Claude Code for architecture, ambiguous debugging, long migrations, and final review, then route mechanical implementation to a faster or cheaper model. Start Claude Code with claude --model claude-fable-5-2, or select Fable 5.2 in the model picker when it is available to your account.

Anthropic released Fable 5.2 on 9 November 2026. It requires Claude Code v2.1.321 or later. The fable alias usually resolves to 5.2. Claude apps gateway sessions can resolve it to Fable 5. Pin claude-fable-5-2 where your provider supports the ID and verify the active model with /model.

Standard API rates are $8 per million input tokens, $40 per million output tokens and $0.20 per million cache-read tokens. Optional fast mode uses $16 and $80 input and output rates where available. The API has a 30-day data-retention requirement unless Anthropic expressly authorizes another arrangement.

Want help wiring model routing, caching, and review gates into your team’s workflow?

 Design the Model-Routing Workflow

Building your own Messages API integration? The Fable 5.2 session replay test checks whether tool calls survive a worker restart and a model rollback.

1. Use Fable for judgment, not keystrokes

The fastest way to waste Fable is to ask it to do every small edit.

Do not use it for:

  • Tiny syntax fixes
  • Simple CRUD changes
  • Renaming variables
  • Formatting
  • Boilerplate generation
  • Routine file search
  • Basic test updates
  • Mechanical implementation steps

Those tasks are usually better handled by a cheaper or faster model.

Use Fable where mistakes are expensive:

  • Architecture decisions
  • Large refactors
  • Migration planning
  • Complex debugging
  • Design reviews
  • Ambiguous product-to-code translation
  • Multi-file dependency analysis
  • Final production review
  • Test strategy
  • Codebase archaeology
  • Long-running agent tasks
  • Pull request review after another model implemented the change

A good mental model:

Sonnet or Opus can be the implementer.
Fable should often be the architect and reviewer.

That also matches what some early practitioner guides are recommending: use cheaper models for triage, repetitive execution, and simple tool calls, then bring in Fable for deeper judgment, migration planning, architecture review, and final decisions.

2. Split coding work into three phases

The most reliable Fable workflow I have found from the docs and community patterns is this:

Phase 1: Explore
Phase 2: Plan
Phase 3: Execute and verify

Fable does not need to own every phase.

A practical setup:

Use a cheaper model such as Sonnet or Haiku to explore the repo, collect files, summarize architecture, identify test commands, and prepare a clean brief.

Use Fable to reason about the hard part: what should change, what could break, what order to do it in, and how to verify it.

Use Opus or Sonnet to implement repetitive edits.

Use Fable again as the final reviewer.

That "Fable sandwich" is often more reliable than asking Fable to blindly do the entire job from the first prompt.

Example workflow:

Sonnet or Haiku: map the repo, identify affected files, summarize current behavior.
Fable: design the safest migration plan and identify hidden risks.
Opus or Sonnet: implement the plan.
Fable: review the diff, tests, edge cases, and rollout risk.
Human: approve the final ship decision.

This is not about bypassing safeguards. It is just good model routing.

If you want to test the same Claude Code harness with an OpenAI model instead, our Claudex setup for GPT-5.6 Sol and CLIProxyAPI shows the complete local connection, security checks and rollback path.

Kevin Riedl

"Sonnet or Opus can be the implementer. Fable should often be the architect and reviewer. The teams that win are the ones that learn how to hand work between models, not force one model through every prompt."

3. Start with planning mode for big changes

For large coding tasks, Fable should often begin in read-only mode.

Claude Code provides plan mode for read-only analysis, plus /model and /effort controls. Use /review for a change review and /security-review for a deeper security pass where appropriate. Check /help in your installed version because commands can change.

A strong Fable prompt looks like this:

/model claude-fable-5-2
/effort high
/plan

Goal:
Design the safest implementation plan for [feature/refactor/migration].

Constraints:
- Do not edit files yet.
- First map the affected files and dependencies.
- Identify assumptions and unknowns.
- Propose the smallest safe change.
- Separate implementation steps from verification steps.
- Tell me which parts should be delegated to a cheaper model.

This does three things.

First, it gives Fable the kind of high-level reasoning task where it makes sense.

Second, it reduces accidental over-editing.

Third, the plan gives the implementer a reviewed scope and clear verification steps.

4. Start with default effort and measure when to raise it

Fable 5.2 defaults to medium in Claude Code and high on the Claude Platform API. Compare the default with high on representative tasks. Test xhigh or max on difficult cases with a defined budget and independent acceptance tests.

5. Make your repo Fable-readable

Fable is powerful, but it is not psychic.

If your project context is messy, Fable will waste tokens discovering things a human team could have written down once.

Claude Code recommends using /init to create a starter CLAUDE.md, then refining it with build commands, test commands, code style, workflow rules, and non-obvious project gotchas. It also warns that bloated CLAUDE.md files can cause Claude to ignore the important instructions.

A good CLAUDE.md should include:

  • How to install dependencies
  • How to run one test
  • How to run the full test suite
  • How to typecheck
  • How to lint
  • Which package manager to use
  • Non-obvious architecture rules
  • Important directories
  • Branch and PR conventions
  • Known traps in the repo

A bad CLAUDE.md includes:

  • Long tutorials
  • Obvious language conventions
  • File-by-file explanations
  • Outdated information
  • Rules that conflict with each other
  • Generic instructions like "write clean code"

A practical CLAUDE.md snippet:

# Project commands
- Install: pnpm install
- Dev server: pnpm dev
- Typecheck: pnpm typecheck
- Unit test one file: pnpm test path/to/file.test.ts
- Full test suite: pnpm test
- Lint: pnpm lint

# Workflow
- Prefer small, reviewable diffs.
- For bug fixes, add or update a regression test first when practical.
- Run typecheck after a series of code changes.
- Do not run the full test suite unless the targeted tests pass first.

# Architecture
- API routes live in src/server/routes.
- Shared domain logic lives in src/domain.
- UI components should not call database code directly.

This makes Fable more reliable because it can spend its reasoning budget on the hard problem instead of rediscovering your workflow.

6. Put repeatable workflows into skills

Do not stuff every workflow into CLAUDE.md.

Claude Code supports skills through SKILL.md files. The docs recommend using skills for domain knowledge and reusable workflows that should load on demand rather than bloating every conversation.

For example, you could create:

.claude/skills/fable-migration-review/SKILL.md

---
name: fable-migration-review
description: Review a proposed code migration for hidden risks and verification gaps
---

Review the proposed migration.

1. Identify affected modules.
2. Find hidden dependencies.
3. Identify backwards compatibility risks.
4. Check whether the plan can be split into smaller PRs.
5. Define targeted tests.
6. Define rollback strategy.
7. Produce a ship/no-ship recommendation.

Then you can invoke it whenever Fable is doing a migration review.

This is a good use of Fable because the value is not in typing code. The value is in catching what another model or engineer might miss.

7. Use hooks for rules that must always happen

Instructions are advisory. Hooks are deterministic.

Claude Code’s docs are very clear here: use hooks for actions that must happen every time with zero exceptions. For example, a hook can run eslint after edits or block writes to sensitive folders.

This matters for Fable because you should not rely on any model to remember every operational rule in a long session.

Good hook ideas:

  • Run formatting after file edits
  • Run lint after edits
  • Block changes to generated files
  • Block changes to migrations unless explicitly allowed
  • Filter huge test logs down to failures
  • Prevent accidental writes to production config
  • Warn when secrets appear in a diff

The docs also note that hooks can reduce token usage by preprocessing noisy output. For example, instead of making Claude read a 10,000-line log, a hook can return only matching error lines.

That is exactly the kind of environment setup that makes Fable more effective: give it the right signal, not all the noise.

8. For security work, be explicit and defensive

For an authorized code review, request the affected file and line, impact, remediation and a regression test. Review authentication, tenant authorization, input validation and secret handling. Keep the review read-only and assign a maintainer to approve changes.

9. Avoid asking for hidden reasoning

Another avoidable fallback trigger: asking Fable to reveal internal reasoning.

Anthropic’s Fable docs say the model has safeguards around extraction of summarized thinking, and the migration guide documents a reasoning_extraction refusal category.

So do not ask:

Show your full hidden chain of thought step by step.

Ask:

Give me the conclusion, key evidence, tradeoffs, risks, and recommended next action.

For coding, this is usually better anyway. You do not need a transcript of the model’s private reasoning. You need an engineering decision you can inspect.

10. Use Fable for code review after another model writes the code

One of the best patterns is:

Let a cheaper model write the diff.
Let Fable review it.

Anthropic reports higher FrontierCode 2.0 results for Fable 5.2 than for Fable 5.1 under its test conditions. Measure accepted changes and review effort in your own repositories.

A practical prompt:

/model claude-fable-5-2
/effort xhigh

Review the current diff as a senior engineer.

Focus on:
- Correctness bugs
- Hidden coupling
- Backwards compatibility
- Missing tests
- Edge cases
- Simpler implementation paths
- Risky assumptions
- Files that should not have changed

Do not rewrite the whole PR. Return only:
1. Must-fix issues
2. Should-fix issues
3. Tests to add or run
4. Ship/no-ship recommendation

This is a perfect Fable task because the model is not just generating code. It is judging whether the work is safe.

11. Use subagents, but do not make all of them Fable

Fable 5.2 can coordinate parallel subagents. Anthropic’s current prompting guide says that letting the lead continue useful work while independent subagents run can reduce completion time at similar quality, token use, and cost.

But that does not mean every subagent should use Fable.

Claude Code’s subagent and cost docs recommend isolating side tasks that would flood the main context and routing simple subagent work to cheaper models such as Haiku.

A better pattern:

Fable = orchestrator
Sonnet or Opus = implementation agents
Haiku or cheaper models = simple scan/extraction agents
Fable = final synthesis and decision

Example subagent setup:

  • Research agent: maps files and dependencies
  • Test agent: finds and runs relevant tests
  • Implementation agent: makes mechanical edits
  • Review agent: checks diff quality
  • Fable orchestrator: decides the plan and final recommendation

Claude Code lets you create custom subagents with /agents, choose their tools, choose their model, and restrict them to read-only tools when appropriate.

This is how you get more Fable-quality output without burning Fable tokens on every repetitive step.

12. Use worktrees for parallel experiments

If you want to test multiple approaches, isolate them.

Claude Code supports git worktrees with claude --worktree, creating separate working directories and branches so edits in one session do not touch files in another.

This works well with Fable:

Ask Fable to propose two or three viable implementation strategies.
Run each strategy in a separate worktree with cheaper implementation agents.
Bring the diffs back to Fable for comparison.
Ask Fable which one is safest to ship.

Prompt:

Compare these three worktree diffs.

Evaluate:
- Smallest safe change
- Test coverage
- Maintainability
- Regression risk
- Compatibility with current architecture
- Rollback simplicity

Pick one. Explain why. Do not merge anything.

Again, Fable is doing what it is best at: synthesis, judgment, and risk analysis.

13. Ask Fable to verify against tool results, not vibes

Fable is powerful, but you should still make it prove its work.

Anthropic’s current prompting guidance recommends explicit self-checks against test criteria. For coding work, require progress and completion claims to match actual tool results.

Use prompts like:

Before reporting success, audit each claim against actual tool output from this session.

Only say something is complete if:
- The code was changed
- The relevant tests were run
- You can cite the command output
- Any skipped verification is explicitly marked as skipped

For implementation tasks:

After making changes:
1. Show the files changed.
2. Run targeted tests first.
3. Run typecheck.
4. If tests fail, stop and report the failure honestly.
5. Do not claim success unless verification passed.

This is especially useful for long sessions where the model may otherwise give an overly confident summary.

14. Keep context small and intentional

Fable has a large context window, but large context is not free.

Claude Code’s cost docs say token costs scale with context size and recommend clearing between unrelated tasks, using /compact with custom compaction instructions, choosing the right model, disabling unused MCP servers, installing code intelligence plugins, and using hooks or skills to reduce unnecessary file reads.

Practical rules:

  • Use /clear when switching tasks.
  • Use /context to see what is consuming space.
  • Use /compact Focus on test output, decisions, changed files, and unresolved risks.
  • Do not keep unrelated debugging history around.
  • Do not paste giant logs when a filtered error summary is enough.
  • Prefer @file references over vague descriptions.
  • Use CLI tools like gh, aws, gcloud, or sentry-cli where appropriate because Claude Code says CLI tools are often more context-efficient than API or MCP alternatives.

Fable works best when the context is rich, not bloated.

15. Handle refusals and incomplete runs

The API can return HTTP 200 with stop_reason set to refusal. Record the run as incomplete even when it returned partial text. Preserve the trace and send the request to the responsible human reviewer. If an approved fallback handles an ordinary availability failure, record the responding model and apply the same permission and acceptance checks.

16. Use this task map

Here is the simplest practical routing map.

This map helps an individual route Fable tasks. If you are choosing the harness, gateway, worker roles and controls for a company, use the separate multi-model AI coding agent stack buying guide. It includes cost per accepted change, buy-vs-build criteria, governance and a 30-day team pilot.

Great Fable tasks:

  • Architecture review
  • Migration planning
  • Complex bug diagnosis
  • Multi-file refactors
  • Final PR review
  • Ambiguous product requirements
  • Test strategy
  • Repository-wide dependency analysis
  • UI review from screenshots
  • Long-running agent orchestration
  • Comparing multiple implementation approaches
  • "Why is this system fragile?" analysis

Good but watch cost:

  • Writing tests
  • Generating implementation plans
  • Producing documentation from code
  • Performance profiling plans
  • API design
  • Data model review
  • CI failure analysis
  • Release planning
  • Large codebase onboarding

Usually not worth Fable:

  • Tiny fixes
  • Boilerplate
  • Simple file edits
  • Formatting
  • Single-function rewrites
  • Dependency bumps
  • Basic documentation cleanup
  • Routine shell commands
  • Simple search-and-replace work

Likely to fallback or require careful defensive framing:

  • Security vulnerability review
  • Authentication and authorization review
  • Exploit-adjacent debugging
  • Malware-like behavior analysis
  • Requests involving payloads or bypasses
  • Requests for hidden reasoning
  • Biology or chemistry workflows

Do not use Fable for:

  • Offensive exploit development
  • Malware
  • Credential theft
  • Bypass instructions
  • Attack tooling
  • Jailbreak attempts
  • Anything where the goal is to evade safeguards

Getting this routing right across a whole team is an operational problem more than a model problem. Deciding which model owns which step, wiring the hooks and skills so the rules hold without anyone remembering them, and leaving a setup the team can run unattended is the work behind our AI enablement service. The same routing discipline applied to a product rather than a workflow is what took Twinsoft AI from a fragile prototype to enterprise pilot-ready. When code an agent wrote has to survive real users, our guide to taking a vibe-coded prototype to production sets out what has to be true before it ships.

17. A practical Fable coding prompt library

Use these as starting points.

The architecture prompt

Use Fable as a senior staff engineer.

Goal:
Evaluate the architecture for [change].

Please:
1. Map the relevant modules.
2. Identify hidden coupling.
3. Identify the smallest safe implementation path.
4. List risks and tradeoffs.
5. Define verification steps.
6. Recommend whether this should be one PR or multiple PRs.

Do not edit files yet.

The implementation handoff prompt

Turn this plan into an implementation brief for a cheaper coding model.

Include:
- Files to edit
- Exact behavioral changes
- Tests to add
- Commands to run
- Things not to change
- Acceptance criteria

The final review prompt

Review the current diff as a senior engineer.

Return:
1. Must-fix issues
2. Should-fix issues
3. Missing tests
4. Regression risks
5. Ship/no-ship recommendation

Ground every claim in the actual diff or test output.

The defensive security prompt

I am reviewing my own authorized codebase.

Perform a defensive review focused on:
- Authentication boundaries
- Authorization checks
- Input validation
- Secrets handling
- Unsafe data exposure
- Test coverage

Do not provide exploit chains, payloads, offensive tooling, or attack instructions.

For each finding, provide:
- File and line
- Risk
- Safe remediation
- Safe regression test

Final thoughts

Fable 5.2 does not mean using the biggest model for every coding task. The better workflow is model routing: use cheaper models for speed, use Opus for strong general coding, use Fable for high-judgment engineering, use hooks, tests, worktrees, and CI for guardrails, and use humans for final accountability.

The teams that get the most out of Fable will be the ones that learn how to brief it, when to invoke it, how to verify it, and how to hand work between models.

The winning workflow is a system: plan with Fable, build with the right model, verify with tools, review with Fable, and ship with human judgment.

Primary sources and review basis

Product, pricing, safeguard, and Claude Code claims were checked on 11 November 2026 against Anthropic’s current sources:

Production AI help

Building an AI product and worried about inference cost, architecture, or production readiness? Wavect helps founders turn AI prototypes into reliable production systems.

Explore the service path:

Inbox, without the noise

Follow the work that matters to you

Get a short email when we publish something new. Follow the whole blog or only the problems you care about.

What would you like to receive?
Choose your topics

Free, double opt-in, no tracking pixels.

Back
Kevin Riedl

16 min read · 02 Jul 2026
Last reviewed

Next

Get the next AI and agents field note

One concise email when we publish. No tracking pixels, and no inbox filler.

Free, double opt-in, no tracking pixels.