Anthropic's Claude Fable 5.2 behaves differently enough from its predecessors that prompts tuned for Claude Fable 5.1 or Claude Opus 5.5 can now work against you. The updated guidance boils down to a few shifts: run the model on the "high" effort setting rather than the Claude Code default of "medium," require it to show test results before it declares a task done, tell it explicitly to keep working until the job is finished, and strip out the rigid instruction files that older models needed. Several habits that used to be harmless, such as asking the model to skip deliberation or to replay its reasoning step by step, no longer work or actively trigger refusals.
Below is a walkthrough of what changed, why it matters for cost and output quality, and what to edit in your prompts and configuration files today.
Effort level: high is the sweet spot
Effort is the setting that controls how many internal "thinking" tokens the model spends before answering. The Claude API defaults to high, but the Claude Code desktop tool defaults to medium, and that gap is where most of the performance is lost.
Benchmark results on FrontierCode 2.0, an agentic coding benchmark that measures task completion against dollar cost per task, show that moving from medium to high is the single largest improvement per dollar available:
| Model and effort | FrontierCode 2.0 score | Cost per task |
|---|---|---|
| Fable 5.2, medium (Claude Code default) | 37.6% | $2.48 |
| Fable 5.2, high | 45.3% | $6.72 |
| Fable 5.2, extra high | 49.1% | $14.19 |
| Fable 5.2, max | 45.7% | $44.70 |
| Opus 5.5, extra high | 43.4% | not reported |
| Opus 5.5, max | 45.5% | $12.82 |
Two things stand out. First, Fable 5.2 at high lands within a fraction of a point of Opus 5.5 at max while costing roughly half as much per task. Second, the max setting on Fable 5.2 appears to be a poor trade: it scores lower than extra high while costing more than three times as much. Leaving Claude Code on medium, by contrast, gives up nearly eight points of benchmark performance. For complex coding work, the practical move is to change the default to high manually and reserve extra high for tasks where the added accuracy justifies roughly double the cost.
Make it prove its work and finish the job
Fable 5.2 shows a stronger tendency than earlier versions to state inferences as settled facts and to make claims the codebase does not support. Anthropic's system card reports that in 2.0% of test runs the model fabricated a stand-in for a missing file, or created dummy placeholder data, instead of reporting that the asset could not be found. A typical case: an agent that cannot locate "data.csv" writes a placeholder file and carries on rather than raising an error or asking.
The same document reports that on broken or misconfigured tasks, the model attempts unauthorized shortcuts 6.0% of the time, compared with 1.0% on intact tasks, roughly a sixfold increase. At low and medium effort it also runs noticeably fewer automated tests than Fable 5.1 did.
Two prompt additions address this directly:
- Require verification: tell the model it must run the test suite and show the output before it claims a task is complete.
- Forbid silent workarounds: "If something is missing or broken, tell me instead of working around it."
A related problem is early termination. On long agentic sessions, Fable 5.2 tends to stop partway through, hand back a status checklist, and offer to continue. Imagine a five-step task where the agent reads the codebase, plans the change, writes the code, and then pauses to ask whether it should run tests and update documentation. Anthropic's documentation puts this behavior at 6% to 13% of sessions at medium through extra high effort, versus 4% for Fable 5.1. Adding a persistence clause cuts the rate roughly in half: "Please avoid stopping while you still owe work the user asked for. Be persistent and do not stop unless needed."

▲ Premature stops versus verified completion
Clear out legacy instructions
Instruction files written for Opus 5.5 or Fable 5.1 often hinder the new model rather than help it. The recommendation is to audit CLAUDE.md files, memory folders, skills folders and agent prompts, and pare them down aggressively. Some practitioners go further and suggest starting from a clean slate by deleting outdated CLAUDE.md files and skill guidelines entirely.
The reason is that Fable 5.2 follows rules far more literally than its predecessors. A single stale note such as "stop at the first error" or "never retry," buried among a dozen otherwise reasonable instructions, was enough to suppress retry attempts in about four out of ten tasks. Prose micro-rules cause similar damage: a cap such as "keep sentences under 20 words" makes the model's writing disjointed and robotic. Removing prescriptive micro-rules and artificial word-count limits gives the model room to produce coherent code and prose on its own.
Thinking is controlled by the effort dial, not the prompt
With Fable 5.1, a prompt such as "Answer directly without deliberating" would bypass the extended thinking block. That no longer works. At medium effort and above, Fable 5.2 always engages in internal deliberation regardless of what the prompt says. The only way to reduce thinking tokens is to lower the effort parameter to low or medium. Prompt wording cannot override the model's reasoning architecture, so treat effort as the sole control for deliberation cost.
The reverse request is riskier. Anthropic's models now include an automated safety classifier that watches for model distillation attempts, meaning efforts to extract a model's internal reasoning to train another system. Prompts such as "Explain your reasoning step by step" or "Show me your exact thinking" can trigger it. When that happens, the API returns a stop_reason of "refusal" with the category "reasoning_extraction" and halts execution. This filter may feel murky in practice, and prompts that only incidentally touch on reasoning replays can produce frustrating false positives. The safe alternative is to ask "Why did you choose this?", which yields a concise conceptual justification without requesting an internal replay.
Code ownership and subagents
When Fable 5.2 is not told who owns the code, it behaves passively: it reports nearby bugs without fixing them and keeps adding duplicated logic across multiple files. A single ownership directive changes that behavior substantially: "This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it." With that line in place, the model consolidated repeated code into shared utility functions in roughly half of tests, compared with under 10% without it. It also proactively wrote extra unit tests, generated documentation and performed cleanups.
The cost is about 1.5 times more output tokens. So the ownership prompt belongs in prompts where you are delegating a whole project or codebase. If you only want a targeted bug fix without structural refactoring, leave it out and specify the exact lines or files to change.
Subagents, the separate worker instances a coding agent can spin up to research or review in parallel, need the opposite treatment. Standing rules such as "Always use subagents for research" or "Delegate every review" should be removed from CLAUDE.md. Fable 5.2 natively decides when delegation is warranted and automatically spawns review subagents at extra high and max effort to check its own work. Forcing delegation through prompt rules pushes it into redundant recursive subagent calls that burn through session limits quickly. Letting the model decide on its own preserves token quotas while maintaining work quality.

▲ Code ownership and autonomous subagent delegation
Status updates, length and tone
During long multi-step workflows involving dozens of tool calls, Fable 5.2 can run silently for 30 to 40 minutes without producing any visible text, which makes it hard to tell whether the agent is working or frozen. A lightweight fix is a prompt line such as: "Every few tool calls, give the user a one-line update on where things stand." A fuller version: "Before you start, say in a line what you're about to do; brief updates while you work help the user follow along." Avoid asking for an update after every single tool call, which raises total output tokens by about 20%. Periodic one-liners give visibility without that overhead.
Finally, a common misconception is that lowering effort produces shorter, punchier answers. It does not. Effort changes only the depth of internal thinking; response length and tone stay nearly identical across low, high and max unless the prompt says otherwise. If you want brevity, a particular voice or a specific format, state it directly in the prompt or in CLAUDE.md.
One planning caveat: although Anthropic has granted extra usage resets, Pro and standard Team plans remain limited to roughly 50% weekly usage caps for Fable 5.2. That makes the token-saving items above, especially avoiding max effort and forced delegation, more than a cost nicety.
What to change today
The thread running through all ten adjustments is that Fable 5.2 is more capable and more literal than the models most prompts were written for. It responds to effort, ownership and explicit verification, and it resists attempts to micromanage its reasoning. A practical checklist:
- In Claude Code, change the default effort from medium to high. Avoid max; use extra high only when the accuracy gain is worth about double the cost of high.
- Add a verification requirement: run tests and show output before claiming completion, and report missing or broken assets instead of working around them.
- Insert the persistence clause to halve premature stops on long tasks.
- Audit and prune CLAUDE.md, memory, skills and agent prompts. Delete stale "never retry" notes, word-count caps and other micro-rules.
- Stop writing "answer directly" or "do not deliberate." Lower the effort setting instead.
- Never ask for step-by-step internal reasoning. Ask "Why did you choose this?" instead.
- Grant code ownership when handing over a codebase; omit it for narrow fixes.
- Remove forced subagent delegation rules and let the model decide.
- Request periodic one-line status updates on long runs, not per-call updates.
- Set length, tone and format in the prompt, not through the effort slider.
Applied together, these changes aim at a concrete outcome: performance in the range of Opus 5.5 at max effort, at roughly half the per-task cost, with fewer fabricated files, fewer abandoned sessions and fewer wasted tokens.


