Source: ai-research/anthropic-docs-prompting-claude-fable-5-2-2026-11-11.md — Anthropic’s “Prompting Claude Fable 5.2” page in the Claude platform docs (platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5-2), fetched 2026-11-11. The page is undated; the model launched 2026-11-09. Behaviour summary also from “What’s new in Claude Fable 5.2” (ai-research/anthropic-docs-whats-new-fable-5-2-2026-11-11.md).
Secondary sources: two creator walkthroughs of the same guide. Ben AI, “Anthropic Just Revealed How to Prompt Fable 5.2” (raw/Anthropic_Just_Revealed_How_to_Prompt_Fable_5.2.md, https://www.youtube.com/watch?v=C45VVcCV9OY, YouTube); Rob at Switch to Dimension, “How to Prompt Claude Fable 5.2 (Anthropic’s Own Guide)” (raw/How_to_Prompt_Claude_Fable_5.2_Anthropic_s_Own_Guide.md, https://www.youtube.com/watch?v=ha1Iu9YWMtw, YouTube). Alex Albert’s tips via The AI Daily Brief (raw/Fable_5.2_vs_Opus_5.5_and_When_to_Use_Each.md).
Anthropic’s guide for Claude Fable 5.2 is organised by symptom, like the Opus 5.5 guide: find the behaviour you see, apply the matching fix, and measure its token cost. The thread running through it is that Fable 5.2 follows instructions more literally than earlier models, so old cautious rules, delegation lines and style limits now cost more than they did. Most of the fixes either delete instructions or make them more exact, and each comes with a measured side effect.
Key Takeaways
- Start at
highon the API and re-run your effort sweep. Effort names rank the same across models but the amount of thinking differs, so do not carry over a Fable 5.1 or Opus 5.5 setting. Most of the gain is athigh; above it gains are “uneven and task-dependent.” (In the Claude apps and Claude Code the default ismedium.) - “Think less” lines no longer work. At
mediumand above the model thinks anyway, even on a greeting athigh. Lower the effort for easy turns instead. - It sometimes stops early, especially at
lowandmedium: listing what is left, offering to continue, or stopping at a timeout. Anthropic’s “Finishing work” block halved such endings in replayed sessions, for about 30% more output tokens. - Say who owns the code. Without an ownership line it adds to existing structure and reports nearby problems instead of fixing them. With “You are the owner and long-term maintainer of this codebase” it consolidated duplicated code in about 75% of runs (under 10% without), for 70 to 80% more output tokens and unrequested changes.
- Approve exactly. Reply “Yes, run the migration on the staging database,” not “continue.” Write approval rules with their scope: “ask for approval before deleting files,” not “never delete files.”
- Clear out caution that has piled up. Memory files, notes and instruction files collect rules like “never retry” that the model keeps obeying; it may have written some itself.
- Long turns can look silent. Check that your client renders progress-update
thinkingblocks (display: "updates"), then add a harness reminder or a one-line system-prompt instruction. - Delegation depends on your harness. In products whose prompts invite delegation it delegates readily, and subagents can be a large share of the bill. Review standing “delegate” lines before adding new ones.
- Final reports need a reader in mind. The “Communicating clearly” block (“Write for an intelligent but low-context reader”) made reports less dense.
- Don’t ask it to write out its reasoning. That returns a
reasoning_extractionrefusal, which has no fallback. Ask for evidence instead. - Change instructions only in new conversations. The preserved-thinking prefix check now applies to every account, so editing
system,toolsor an earlier message can return a 400 on a resumed conversation.
The guide by symptom
| What you see | What the guide says to do | What Anthropic measured |
|---|---|---|
| Unsure which effort to run; easy requests start slowly | Start at high, test medium and xhigh on your evals; drop to medium where evals hold; lower effort for easy turns rather than prompting “answer directly” | low scored close to Fable 5.1 at higher effort on coding; medium to high raised most coding and knowledge-work scores; xhigh raised coding scores slightly for many more tokens |
| A turn ends before the work is done | Add the “Finishing work” block; keep your own confirmation for risky actions | About half as many sessions ended with continuable work; removed most permission-asking endings, not “list what remains” endings; output tokens up about 30% |
| Agent waits for approvals or holds routine messages | State exactly what you approve; list the specific steps that need approval | A rule listing “sending messages to people outside this conversation” held back about half of routine requests to colleagues |
| Coding agent duplicates code or reports problems without fixing them | Add the ownership sentence where you want restructuring; leave it out where the user owns the code | Consolidation under 10% without, about 75% with; output tokens up 70 to 80%; some runs changed existing behaviour; “No drive-by refactors” earlier in the prompt did not cancel it (still over half) |
| Long agentic turns look silent | Set display: "updates"; add a turn-scoped harness reminder after several silent steps; or add the “Signal intent” or one-line update text | Reminder roughly halved the longest silent stretch with no noticeable token or time increase; “Signal intent” text gave an opening line in every run for about 20% more output tokens |
| More subagents than the task needs | Review prompts and skills that tell it to delegate; then rewrite the subagent tool description to state cost, when delegation is worth it, and how to brief | A longer cost-focused description roughly halved subagent count at high |
| Unneeded approvals, held routine work | Delete stale notes; name steps that need no approval; narrow stop conditions; scope every “never” | Seen mostly when several agents worked together |
| Prompts written for Fable 5.1 or Opus 5.5 | Review the six practices below | See below |
| Final reports hard to follow | Add the “Communicating clearly” block; remove old hard style limits first | Less dense reports, fewer semicolons, shorter sentences on workflow tasks |
stop_reason: "refusal" | cyber / bio: apply to the Verification Programs (Mythos 5.2); reasoning_extraction: remove reasoning-in-response instructions and read display: "summarized" thinking | Not stated |
Six things to remove or re-test when migrating
- Standing instructions to delegate in system prompts, skills and agent files.
- A token budget shown to the model. Its size changes how much the model spends; removing a large one at
highandxhighlowered cost with equivalent performance. (This is prompt text, not the API’s task-budgets beta.) - Harness code that edits earlier turns. It invalidates the thinking blocks after the edit; use context editing or compaction, or keep history append-only.
drop_blockavoids the error but makes the model think again. - The Opus 5.5 “treat that answer as done” lines. On Fable 5.2 at
highthey cut follow-up thinking and made the model “far less likely to point out mistakes in its earlier answers.” - Instructions to think less. Fable 5.1 usually followed them; Fable 5.2 does not at
mediumand above. - Hard style rules such as “one instruction per sentence, in 20 words or fewer,” which make its prose choppy; and built-up rules, notes and memories, which should be deleted or rewritten “with their scope and reason.”
Where to start (the guide’s own order)
- Set
efforttohighexplicitly, then run your evals atmediumandxhightoo. - Read every system prompt, skill, agent file, memory file, note and harness text you carry over, and remove or test what the migration list above describes.
- Run your longest agentic tasks and note where it stops early, asks for approvals it doesn’t need, goes quiet, over-delegates, or adds to code you wanted restructured.
- Add one fix at a time and measure its effect and token cost.
How the creators’ tips map to the guide
| Creator tip | Guide or other first-party source | Caveat |
|---|---|---|
| Ben 1: don’t switch models mid-chat (lose reasoning and cache) | What’s new: only Fable 5.2 and Mythos 5.2 read Fable 5.2 thinking blocks; playbook: the cache belongs to the model that wrote it | His “up to 40 times cheaper” cached turn and “about an hour” subscription cache are not in these sources |
Ben 2 / Rob: default to high; plan on medium, run on high | Guide (high API default; mix levels per message); launch page and playbook (medium default in apps and Claude Code) | Rob calls this “disagreement at Anthropic”; it is a per-surface default |
| Ben 3 / Rob 1: give the whole task up front; describe the outcome, not the steps | Launch page: it produces “high-quality results from even ambiguous requests”; docs recommend it for long unattended work | Ben’s four-part frame (job, why, guardrails, what done looks like) is his own |
| Ben 4: ask for a one-line update every few tool calls | Guide, verbatim | The guide prefers the harness reminder where available |
| Ben 5: paste “write for an intelligent but low-context reader” | Guide (“Communicating clearly”) | His ELI5 output style is his own |
| Ben 6 / Rob 2: add the “keep going” block | Guide (“Finishing work”) | Rob’s warning matches the guide: keep your own confirmation for risky or irreversible actions |
| Rob 3: say who owns the code | Guide | Rob’s rule (leave it out for someone else’s code) matches |
| Rob 4: watch subagent cost; built-in Explore runs on the session model | Guide (subagents); playbook (Explore change, model: haiku) | Rob says Anthropic says delegation lines are no longer needed; the guide says to review them and remove them if it over-delegates |
| Rob 5 / Ben 7: rules are followed literally; audit old rules | Guide (“Keep caution from piling up,” “Review prompts”) | Ben’s /doctor prompt-audit is his workflow, not in the guide |
| Ben 8: ask for proof, not reasoning | Guide (reasoning_extraction) | His claim that Anthropic saw it “state guesses as if they were facts” is not in the guide or launch page, which reports less hallucinating than earlier models; his “show me the exact source and rows” prompt is his own |
| Rob: “you don’t need to tell it to run tests anymore” | Not in the guide or what’s-new page fetched here | Unverified |
Alex Albert’s tips (Anthropic, via The AI Daily Brief): “ask what’s wrong with your idea before it builds anything”; tell it up front where it needs approval “and be clear that the rest is its call”; start on medium or high and save xhigh for the hardest problems; give it “a whole project instead of a next step.” His stock prompt for each new model (via Rob): “read this entire project and find everything that’s broken, fix what you’re sure about and list the rest for me to review.”
Try It
- Search your CLAUDE.md, skills, agent files and memory for “never”, “always”, “delegate”, “think less”, “answer directly”, “explain your reasoning” and hard word limits. Delete what no longer has a reason; rewrite each “never” with its scope.
- For an unattended agent at
lowormedium, add the “Finishing work” block below and compare unfinished-session counts and output tokens on five runs. - On a codebase you own, add the ownership sentence to one task and review the diff, not just the summary; Anthropic found summaries “often left out small changes.”
- When it stops to ask, answer with the exact action you approve.
- Instead of “explain how you got these numbers,” ask “for every number in this summary, show me the exact source and the rows it came from” (Ben AI).
Implementation
Tool/Service: Claude Fable 5.2 (claude-fable-5-2) and Mythos 5.2 via the Claude API, Claude Code and the Claude apps.
Setup: Make prompt changes in new conversations only; mid-conversation, put new instructions in the newest turn or a mid-conversation system message.
Cost: 40 per MTok (see Fable 5.2). Every fix has a token cost the guide measured: finishing block about +30%, ownership +70 to 80%, signal-intent text about +20%.
Integration notes:
- Progress updates arrive as
thinkingblocks whose text is empty at the defaultdisplay: "omitted"; set"updates"(betathinking-display-updates-2026-08-18) or"summarized". - The harness reminder is a turn-scoped system message (
clear_at: "next_user_message", betamid-conversation-system-clear-at-2026-08-21). Leave each reminder inmessagesafterwards; removing one edits an earlier turn. - Per-message effort (beta
mid-conversation-output-config-2026-07-01) keeps the cache; a new top-leveleffortrestarts it.
Copy-ready text from the guide:
# Finishing work
Please avoid stopping while you still owe work the user asked for. Be persistent and do not stop unless needed.
While status notes are welcome, as is clarifying with the user on open decisions, carry on with work that does not depend on the user's answer without unnecessary stops.
If you notice yourself inviting the user to redirect you or offering to wait, instead proceed on the next part of the task. You may meet ordinary obstacles like errors, timeouts, locked files, empty results or failing tools. Diagnose them first, and when they are not real blockers, work through them with the access you have (wait and retry, fix the request, use another tool or source) rather than stopping unnecessarily.
If someone clearly decided something is a hard blocker, such as a file marked not to be touched, access that was intentionally withheld, or a safety guardrail, leave it alone, say plainly what you found, and look for another safe way to finish the task. Stopping before the task is complete is very rarely merited, as in when the task can't move forward without user input, or where the blocker is deliberate and should not be worked past. This does not override the need for confirmation on risky or destructive actions.You are the owner and long-term maintainer of this codebase, and its design is up to you.The user hasn't heard from you in a while: say in a few words what you're doing, then continue.Before you start, say in a line what you're about to do; brief updates while you work help the user follow along. Close with a short recap that stands on its own (what you found, what you did, and what's next), so a reader who only sees the last message has the full picture.Every few tool calls, give the user a one-line update on where things stand.# Communicating clearly
Write for an intelligent but low-context reader. The person reading has not seen your tool calls, your reasoning or the files you opened, and may be switching in from other work. Messages should generally be self-contained: the reader should understand what you mean without having to dig for other context. Put the key points in the first few sentences. Practice progressive disclosure in your sentence order, and do not use undefined references and ideas in line 1 that won't make sense until the reader reaches line 12.
Use plain words, and write in clear, understandable full sentences. Do not use a term or abbreviation that you made up during the work. Say what the thing is in a way any reader would understand. Write mostly in the style of ASD-STE100 Simplified Technical English: short sentences, one idea per sentence, active voice, and consistently using the same word for the same thing. Use a paragraph of flowing prose where ideas connect, and keep bullets for lists of separate items. Leave out unnecessary details unless the reader asks and practice concision, but do ensure that your messages have the key context. Aim to make your user-facing text as human-readable and clear as possible.Practitioner prompts (not Anthropic guidance)
-
Greg Isenberg’s “grill me” prompt: “Interview me with 20 questions about how I make decisions in my business one at a time, then turn my answers into a skill file you’ll follow from now on.” See his twelve prompts.
-
Claire Vo’s tip for visual work: give it a brand or style guide; she found it follows one well and has poor taste without one. See her first impressions.
-
2026-11-11, Peter Yang (
raw/You_re_Using_Fable_5.2_WRONG_It_s_a_Superpower_With_Opus_5.5.md, https://www.youtube.com/watch?v=fAkm3YQg73s, sponsored by Anthropic) relays the same four tips from “Alex from Anthropic” and adds: “I know most Anthropic employees use Fable on medium effort.” His new-model audit prompt: “please find bugs and issues with this project so we can fix and do potential UI cleanup improvements.” For skills, he runs/claude-api prompt-auditon Fable and asks it to mine past sessions for feedback he has repeated, then reviews each proposed copy edit; improving a skill from one conversation “tends to overfit.” (Theprompt-auditargument was not checked against Anthropic docs.) See Fable 5.2 vs Opus 5.5 head-to-head tests. -
2026-11-13, Nate B Jones: hand it the failures, not a spec (
raw/Claude_Fable_5.2_read_a_month_of_my_failed_attempts_and_got_it_right_the_first_time..md, https://www.youtube.com/watch?v=owMtQh_3k4k, podcast). For a design he could judge but not describe, he gave Fable 5.2 the files from three failed attempts plus his earlier rejection feedback (“mostly … I just said it sucks, it doesn’t work, fix it”) and told it that part of the job was inferring what he had been pointing at. It produced a design he accepted first time. He frames his own role as the judge or customer, not the designer. Separately, when the design thread’s context was nearly full, Fable wrote a handoff file on its own and suggested a fresh thread for the build. Anthropic’s guide has a matching instruction block for handoffs (see “Make reports easy to follow” above); the unprompted behaviour is his single observation. -
2026-11-13, Jay: loop visual work. One prompt gave 3D output well below the demos he had seen; repeating “improve the visual look” on the current output three more times closed most of the gap, on both Fable and Opus (
raw/The_NEW_Claude_Fable_5.2_-_No_Hype_Tests_and_7_Great_Use_Cases.md; see head-to-head tests and Gauntlet Loop). He also found Fable’s raw marketing copy still reads as AI-written (eyebrow headings, extra lines), so copy needs your own voice rules.
Open Questions
- Does Claude Code’s
/effortuse per-message effort (and so keep the cache) on Fable 5.2? Ben says changing effort mid-chat keeps the cache; the guide documents only the API beta. Same open question as on Opus 5.5. - The subagent tool description. The guide describes what a good one says but gives no copy-ready text.
- The migration guide (
platform.claude.com/docs/en/models/fable-5-2/migration-guide) was downloaded but not read for this article; its prefix-check test is summarised only through the what’s-new page. - Rob’s “no need to ask for tests” and Ben’s cache figures (up to 40x cheaper cached turns, one-hour subscription cache) have no first-party source in the vault.
Related
- Claude Fable 5.2 + Mythos 5.2 — the model, pricing, benchmarks and when to use it.
- Prompting Claude Opus 5.5 — the previous symptom-by-symptom guide; its “settled answers” lines are flagged here.
- Prompting Claude Fable 5 — the first Fable guide and the
reasoning_extractionpitfall. - Claude Prompting Best Practices — the cross-model guide.
- Which Effort Level to Use — per-level rules across models.
- Subagents — pinning subagent models and writing their descriptions.
- The New Rules of Context Engineering for Claude 5 — the delete-instructions thesis this guide continues.