Claude Fable 5.2 Prompting Guide: Anthropic's 11 Rules, What to Paste and What to Delete

Anthropic's most capable public model sometimes quits before the job is done, goes quiet for long stretches, and asks for permission it does not need. The instructions you wrote for the last model can also make it slower and more expensive. Anthropic says so itself, in the official guide to prompting Claude Fable 5.2.

The good news is that almost every one of those problems has a fix, and the fix is a few lines of plain text. Anthropic wrote the lines, tested them, and published the numbers. The page has eleven sections, so here are all eleven, in order: what you will notice, what to paste, what Anthropic measured, and what it costs you.

When we say "paste this", we mean your system prompt, the standing instructions a model reads before every conversation. In Claude Code that is your CLAUDE.md file. In the Claude app it is your project instructions.

1. Set the effort dial on purpose

Effort is a setting with five levels: low, medium, high, extra high, and max. It controls how much the model thinks, how long a turn takes, and how many tokens (small chunks of text, the thing you pay for) it uses.

Anthropic's advice is to start at high. That is the default on the API, and most of the gain in capability is already there. Extra high is only for your hardest long-running work, where you have measured a gain. In Anthropic's own coding tests, it raised scores slightly and used many more tokens.

Two surprises. At low, this model scored close to Fable 5.1 at higher effort levels, so low is not the dumb setting. And at high and above, it thinks before almost every reply, even a reply to a greeting. An instruction to answer directly did not stop it. If easy requests feel slow, lower the dial. Do not argue with the model.

2. Make it finish the whole task

On long jobs with many steps, Fable 5.2 sometimes ends its turn early. It hands you a list of what remains, or stops at an ordinary obstacle like a timeout. This happens more often at low and medium effort.

The fix is a block of text titled "Finishing work". It tells the model to work through ordinary obstacles, like errors and timeouts, and to leave deliberate ones alone, like a file marked not to be touched.

Anthropic replayed recorded sessions from a coding product at medium effort. With a version of this text, about half as many sessions ended with doable work left. The price: output tokens rose by about 30 percent. And keep your own confirmation step for anything risky or irreversible.

3. Approve like you mean it

When the model stops and asks, do not answer with a bare "continue", or "go", or a thumbs up. Say exactly what you are approving. Anthropic's example: "Yes, run the migration on the staging database."

If your instructions contain approval rules, name the exact actions they cover, because this model applies them as written. In one test, a rule said messages to people outside the conversation need approval. With nobody there to approve, the model held back roughly half of its routine requests.

4. Tell it who owns the code

When your prompt says nothing about ownership, Fable tends to add on top of what exists, even when that repeats existing code. The fix is one sentence, twenty words:

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 sentence, the model merged repeated code in about half of the tries. Without it, in under a tenth.

The catch

• It used about one and a half times the output tokens.
• It made changes nobody asked for, many of them new tests and documentation.
• In one try out of six to ten, it changed how an existing feature behaves.
• Its closing summary often left out the small changes. So review the diff, and not only the summary.

5. Stop the long silences

During long runs of tool calls, Fable 5.2 sometimes writes very little for the user. Pick a fix:

1. In your harness (the code that runs the agent): after several steps where the user got nothing to read, add this reminder: "The user hasn't heard from you in a while: say in a few words what you're doing, then continue." That roughly halved the longest silent stretch, with no noticeable increase in tokens or time.
2. A pasted block for an opening line, brief updates, and a closing recap. With it, the model spoke before its first tool call every time. It costs roughly 20 percent more output tokens per task.
3. One sentence, if you cannot change the harness: "Every few tool calls, give the user a one-line update on where things stand." That cut most long silent stretches.

6. Set expectations for subagents

A subagent is a helper that the model starts to do one part of the job. If Fable starts more helpers than the job needs, first look for lines in your own prompts that tell it to delegate. Only then rewrite the description of the tool that starts subagents. A good description states what a subagent adds to the cost, says when delegating is worth it, and tells the model how to brief the helper. Cost goes first. With that description, the model delegated about a third less often, and task success stayed the same.

7. Keep caution from piling up

Every "never", every "be careful", every note from an old session collects in memory, notes, and instruction files. Fable 5.2 follows those instructions closely, so over time your agent holds back routine work. The page gives four cleanups:

1. Remove notes you no longer need. A single old note that said "never retry", among a dozen, cut retries after a busy tool from nearly all of the tries to about four in ten.
2. Name the steps that need no approval. One line that listed retries raised them from almost none to about half. A general instruction to act more freely changed nothing.
3. Check what reviewer agents attach. A reviewer's "stop at the first error" made Fable skip the retry in about a third of the tries.
4. Write the exception into the rule itself. Under a flat "never" rule, the model took an approved step about one time in ten. When the rule itself said to get a go-ahead first, nine times in ten.

8. Review instructions written for older models

Some old instructions now raise cost, cause side effects, or do nothing. The page lists seven:

1. Standing instructions to delegate.
2. A token budget written into the prompt. At high and extra high effort, removing a large budget lowered cost, with equivalent performance.
3. Code that edits earlier turns. Fable 5.2 keeps its earlier thinking. If your harness changes an earlier message, that thinking becomes invalid, and the API can reject the request.
4. The "treat that answer as done" lines from the Opus 5.5 guide. The model became far less likely to point out mistakes in its own earlier answers.
5. Lines like "answer directly without deliberating". They no longer work at medium and above. Lower the effort level instead.
6. Hard style rules. A limit like twenty words or fewer per sentence can make its writing choppy.
7. Rules, notes, and memories that have built up. Delete the cautions whose reason no longer holds.

9. Make reports easy to follow

Anthropic's block here is titled "Communicating clearly". It tells the model to write for an intelligent but low-context reader, put the key points in the first few sentences, and skip abbreviations it made up during the work. In Anthropic's tests, this text made final reports less dense, with fewer semicolons and shorter sentences.

10. Know why it refuses

Fable 5.2 runs safety classifiers that can decline a request. On the API, a declined request comes back with a stop reason of refusal, and a category. There are five: cyber, bio, frontier LLM (helping develop competing AI models), reasoning extraction, and general harms.

If your prompts, skills, or tool descriptions ask the model to write its reasoning in the answer, remove those instructions. To see how it reasoned, turn on summarized thinking and read the thinking blocks instead.

11. The order to apply them in

1. Set effort to high explicitly, then run your tests at medium and extra high as well.
2. Read everything you carry over: system prompts, skills, agent files, memory files, and notes. Remove or test the old instructions from number eight.
3. Run your longest tasks and watch where the model stops early, asks for approvals it does not need, goes quiet, or delegates too much.
4. Apply the fix for each behavior you actually saw, one at a time, and measure its effect and its token cost.

Notice the order. Clean up first. Observe second. Paste last. Several blocks cost tokens, so do not paste them all on day one.

One catch applies to all eleven: make these changes in new conversations. Changing the instructions in the middle of a stored conversation can return an error.

Source, read November 10, 2026: Anthropic, "Prompting Claude Fable 5.2".

Get the Fable 5.2 Paste Sheet

Every block of paste text from that page is on one sheet, word for word, with what each one fixes and what it costs. Comment MANUAL on the video, or grab it below.

How we covered this: we ran no tests of our own. Every number is Anthropic's, as published on its prompting page. Independent, not affiliated with Anthropic.