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 high on 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 at high; above it gains are “uneven and task-dependent.” (In the Claude apps and Claude Code the default is medium.)
  • “Think less” lines no longer work. At medium and above the model thinks anyway, even on a greeting at high. Lower the effort for easy turns instead.
  • It sometimes stops early, especially at low and medium: 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 thinking blocks (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_extraction refusal, 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, tools or an earlier message can return a 400 on a resumed conversation.

The guide by symptom

What you seeWhat the guide says to doWhat Anthropic measured
Unsure which effort to run; easy requests start slowlyStart 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 doneAdd the “Finishing work” block; keep your own confirmation for risky actionsAbout 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 messagesState exactly what you approve; list the specific steps that need approvalA 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 themAdd the ownership sentence where you want restructuring; leave it out where the user owns the codeConsolidation 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 silentSet display: "updates"; add a turn-scoped harness reminder after several silent steps; or add the “Signal intent” or one-line update textReminder 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 needsReview 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 briefA longer cost-focused description roughly halved subagent count at high
Unneeded approvals, held routine workDelete 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.5Review the six practices belowSee below
Final reports hard to followAdd the “Communicating clearly” block; remove old hard style limits firstLess 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" thinkingNot stated

Six things to remove or re-test when migrating

  1. Standing instructions to delegate in system prompts, skills and agent files.
  2. A token budget shown to the model. Its size changes how much the model spends; removing a large one at high and xhigh lowered cost with equivalent performance. (This is prompt text, not the API’s task-budgets beta.)
  3. 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_block avoids the error but makes the model think again.
  4. The Opus 5.5 “treat that answer as done” lines. On Fable 5.2 at high they cut follow-up thinking and made the model “far less likely to point out mistakes in its earlier answers.”
  5. Instructions to think less. Fable 5.1 usually followed them; Fable 5.2 does not at medium and above.
  6. 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)

  1. Set effort to high explicitly, then run your evals at medium and xhigh too.
  2. 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.
  3. 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.
  4. Add one fix at a time and measure its effect and token cost.

How the creators’ tips map to the guide

Creator tipGuide or other first-party sourceCaveat
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 itHis “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 highGuide (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 stepsLaunch page: it produces “high-quality results from even ambiguous requests”; docs recommend it for long unattended workBen’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 callsGuide, verbatimThe 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” blockGuide (“Finishing work”)Rob’s warning matches the guide: keep your own confirmation for risky or irreversible actions
Rob 3: say who owns the codeGuideRob’s rule (leave it out for someone else’s code) matches
Rob 4: watch subagent cost; built-in Explore runs on the session modelGuide (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 rulesGuide (“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 reasoningGuide (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 hereUnverified

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

  1. 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.
  2. For an unattended agent at low or medium, add the “Finishing work” block below and compare unfinished-session counts and output tokens on five runs.
  3. 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.”
  4. When it stops to ask, answer with the exact action you approve.
  5. 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 thinking blocks whose text is empty at the default display: "omitted"; set "updates" (beta thinking-display-updates-2026-08-18) or "summarized".
  • The harness reminder is a turn-scoped system message (clear_at: "next_user_message", beta mid-conversation-system-clear-at-2026-08-21). Leave each reminder in messages afterwards; removing one edits an earlier turn.
  • Per-message effort (beta mid-conversation-output-config-2026-07-01) keeps the cache; a new top-level effort restarts 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-audit on 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.” (The prompt-audit argument 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 /effort use 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.