In this piece
How to Use Claude Fable 5.2 in Claude Code
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 WorkflowBuilding 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.

"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 recommendationThis 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 skippedFor 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
/clearwhen switching tasks. - Use
/contextto 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
@filereferences over vague descriptions. - Use CLI tools like
gh,aws,gcloud, orsentry-cliwhere 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 criteriaThe 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 testFinal 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: