Claude Fable 5.2 Prompting Guide: Say Who Owns the Code

Fable 5.2 best practices start with one behavior. Unless a prompt says the code is the model's own, Claude Fable 5.2 tends to add code beside what already exists, even when that repeats it, and to report nearby problems instead of fixing them. Anthropic's prompting guide for Fable 5.2, the model it released on November 9, 2026, covers this in a section called "Say who owns the code." The one-line prompt in that section is the part people are sharing:

This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it.

In Anthropic's testing on small coding tasks, that sentence took the model from merging repeated code in under a tenth of tries to about half. It also cost about 1.5 times the output tokens and brought changes nobody asked for. This prompting guide covers that trade first, then every other section of Anthropic's guide, mapped to the file in Claude Code where each change belongs. Benchmarks, pricing, and API changes are in our Claude Fable 5.2 launch breakdown and are not repeated here.

Anthropic's guide is written for the API and never mentions Claude Code. Every Claude Code mapping below comes from Claude Code's documentation or from our own reading of the Claude Code 2.1.322 binary, and we label those mappings as ours. Each section says whether its guidance is new for Fable 5.2 or carried over from the Fable 5.1 and Opus 5.5 guides. The guidance also covers Claude Mythos 5.2. For techniques that apply to every current model, see Anthropic's Claude prompting best practices.

This Codebase Is Yours: What the Ownership Sentence Does

New in Fable 5.2. No earlier Fable or Opus guide has this section. The Fable 5.1 guide pushed the other way: its block on keeping changes to the task told the model to leave a pre-existing bug alone and "report it as a follow-up in your summary." Fable 5.2 does that by default when the prompt says nothing about ownership.

Anthropic's framing is that "Claude Fable 5.2 responds closely to what the prompt says about who owns the code it works on." Every result below comes from its testing on small coding tasks, quoted as written:

The feature works either way, so the sentence decides what else lands in the diff. Plan around the behavior-change row: an existing feature behaved differently in one try in six to ten, and the closing summary is where small changes go unmentioned.

Claude Code Says Nothing About Ownership by Default

We searched the Claude Code 2.1.322 binary and found no ownership sentence and no wording about who owns the code. Fable 5.2 also runs on Claude Code's shorter system prompt. The environment variable docs say that when CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT is unset, "newer models use the shorter one," and the output styles docs say the shorter prompt leaves out the section on "how to scope changes." Our read: a stock Claude Code session on Fable 5.2 matches the condition Anthropic tested with nothing said about ownership. Expect added structure and reported problems until you say otherwise.

Where the Ownership Sentence Goes in Claude Code

In Claude Code, "the prompt" is assembled from several files, and each one loads in a different set of sessions. This mapping is ours, built on the memory docs and subagent docs.

The CLAUDE.md guide covers how these files stack. A refactoring agent is the narrowest home, because the sentence loads only when you call that agent.

Before (~/.claude/CLAUDE.md, loads in every repository):

This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it.

After (.claude/agents/refactorer.md, loads only for this agent):

---
name: refactorer
description: Restructures a module when asked to refactor it. Not for feature work.
omitClaudeMd: true
---
 
This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it.
 
Run `npm test` before you finish. When you finish, list every file you changed, including new tests and docs.

omitClaudeMd: true starts the agent without your user, project, and local CLAUDE.md files, so the build and test commands go in the agent file. It requires Claude Code v2.1.271 or later, and the case study below explains why it is there. The last line is ours, aimed at the summary gap. We have not measured whether it closes that gap, so review the diff anyway.

Where It Must Stay Out

Anthropic's rule: "Leave the ownership sentence out where the user owns the code and wants it changed as little as possible." In Claude Code work, our mapping of that rule covers four cases:

• Client repositories. Every merged helper and new test file is something the client has to review.
• Open-source contributions. Maintainers want the smallest change that fixes the issue, which is why ~/.claude/CLAUDE.md is the wrong home for the sentence.
• Reviewing someone else's pull request. The default behavior, reporting nearby problems instead of fixing them, is what a review needs.
• Hotfix branches. The smallest correct change is the point of the branch.

The Diff Review the Sentence Requires

Anthropic says to "review the diff and not only the summary." In Claude Code that takes two commands before you accept the work:

git status --short   # new files, such as tests and docs nobody asked for
git diff --stat      # every changed file, including small ones the summary skipped

Then read the diff for an existing feature that now behaves differently, and run the tests for the features next to the one you asked about. If a refactoring agent carries the sentence, the lead should treat its report as a claim to check, the habit covered in why a subagent's "done" is not proof.

Case Study: Our CLAUDE.md Takes the Other Stance

The CLAUDE.md we run in this site's repository, and deploy unchanged to 11 of our projects, carries this rule:

Surgical scope. Every modified line traces to the request. Adjacent improvements, dead code, and formatting opportunities get a mention at the end, never bundled in. No speculative abstraction: nothing is generalized, parameterized, or given an extension point for a requirement the request does not name. Before changing a feature, check its downstream consumers.

That rule asks for the behavior Anthropic describes for code the model does not own: mention the nearby problem and leave the structure alone. On Fable 5.2 it points the same way as the default.

It should not share a prompt with the ownership sentence. Anthropic's test put a scope rule and the sentence in one prompt and still got merges in about a third of tries, and Claude Code's memory docs warn that "if two instructions contradict each other, Claude may pick one arbitrarily." Our conclusion is one stance per repository. A file shared across 11 projects can only hold the stance that is safe in all of them, and that is scope. Where we want code restructured, the sentence goes into a refactoring agent that starts with omitClaudeMd: true, so it never sees both rules.

Skip it when: the user owns the code and wants it changed as little as possible, or a reviewer will reject unrequested tests and docs.

How to Use Fable 5.2 in Claude Code

Fable 5.2 requires Claude Code v2.1.321 or later, per the model configuration docs, and the 2.1.321 changelog entry made it the default Fable model. The launch breakdown covers the alias changes that shipped with it.

claude update
/model fable
/effort high      # saved per model, so this becomes your Fable 5.2 default

Two facts change how Anthropic's guide applies in Claude Code:

• Claude Code starts Fable 5.2 at medium. The model configuration docs list Fable 5.2 among the models that "default to medium." Anthropic says to "Start at high, the default on the Claude API," and that the model "is more likely to stop early at lower effort levels."
• "Add this text to your system prompt" means a file. That text goes in CLAUDE.md for every session, a subagent file for one agent, an output style with keep-coding-instructions: true for the main conversation, or --append-system-prompt for one run. Claude reads CLAUDE.md "at the start of every session," so start a new session after an edit. Anthropic's advice to change prompts "in new conversations only" is about an API error, and its what's-new page says that error does not affect you when Claude Code builds your requests.

What Claude Code Already Adds for Fable 5.2

We read the Claude Code 2.1.322 binary, the current release on November 10, 2026, to see which of Anthropic's blocks it already sends. Each model gets a prompt bundle, and Fable 5.2's bundle is separate from Fable 5.1's.

This reading has two limits. Anthropic can change these blocks from its servers without a release, so check again after an update. Some entry points other than the terminal skip the bundle entirely.

What Is New in Fable 5.2 and What Carried Over

What carried over from Fable 5 itself, such as briefing the outcome instead of the steps, is in the Fable 5 practices.

Fable 5.2 Effort Level: Start at High for Long Runs

Carried over, rewritten.

Anthropic's line: "Start at high, the default on the Claude API," because "Most of the gain in capability is already present at high." The guide gives each level a job:

• low: "quick back-and-forth, well-specified tasks, and high-volume workloads, such as fast, intelligent subagents."
• medium: "interactive coding, chat, and everyday knowledge work."
• high: "hard coding, research, agentic work, and long unattended runs."
• xhigh: "your hardest long-running coding and agentic work, where you've measured a gain."
• max: "for measuring the model's ceiling, or for the rare task where time and tokens don't matter."

Early stops are more likely at low and medium. At high and above, the model "thinks before almost every reply, including a reply to a greeting." And "Effort barely changes how long the model's replies are," so length and tone belong in the prompt.

In Claude Code: the session starts at medium. Run /effort high before long unattended work, set effort in a subagent's frontmatter to move the dial per task, and type ultrathink, which can raise a single turn to xhigh. Anthropic's suggestion to "plan and iterate with the model at medium, then raise effort for the long, unattended part" maps to planning in the session and running /effort high before the long run.

Claude Code's docs and Anthropic's testing disagree on one point. Claude Code's docs say a prompt or CLAUDE.md line asking Claude to think less works "within its effort setting." Anthropic found such a line "didn't stop the model from thinking at medium and above" on Fable 5.2. Use the dial.

Before (CLAUDE.md, carried from Fable 5.1):

Answer directly without deliberating.

After (line deleted, and the scout agent sets its own level):

---
name: file-scout
description: Finds files and call sites, returns paths only
effort: low
---

Skip it when: you pair at medium and your tasks finish. Anthropic says to "move down to medium wherever your evals show that quality holds." The Claude Code effort ladder covers what each level costs, and model versus effort covers when the model is the problem.

Finish the Whole Task Without Pasting the Block

Carried over, new text.

Anthropic's line: "On long, multistep tasks, Claude Fable 5.2 sometimes ends a turn before the work is done. The turn closes with a list of what remains, an offer to continue, or a stop at an ordinary obstacle such as a timeout." The guide's Finishing work block tells the model to work through ordinary obstacles and leave deliberate blockers alone. In recorded sessions Anthropic replayed at medium, a version of the block meant "about half as many sessions ended with doable work left." It "removed most endings that ask permission or offer to continue, but not endings that list what remains and then stop," and output tokens "rose by about 30 percent."

In Claude Code: by our reading of the 2.1.322 binary, Claude Code already sends a reworded version for Fable 5.2, so pasting the block sends it twice. The ending it leaves behind, a turn that lists what remains and stops, is what /goal handles: after each turn, a model "checks whether the condition holds," and if it does not, "Claude starts another turn." Our read: /goal covers the residual case Anthropic measured.

Before:

Migrate every v1 endpoint to the v2 client.

After:

/goal every v1 endpoint uses the v2 client and npm test exits 0, or stop after 30 turns

Anthropic adds: "keep your own confirmation step for risky or irreversible actions." For your own completion logic instead of /goal, see Stop hook task enforcement.

Skip it when: you are watching the session and want to steer each step.

Approvals: Name the Action You Approve

New in Fable 5.2.

Anthropic's line: when you tell the model to keep going, "say clearly what you want from it instead of sending a bare 'continue.'" Its example reply is "Yes, run the migration on the staging database" in place of "go" or a thumbs-up. Approval rules need the same precision, "because the model applies them as written." With nobody there to approve, one rule listed "sending messages to people outside this conversation" as needing approval, and the model "held back roughly half of its routine requests to colleagues and other teams."

In Claude Code: approvals live in two layers, and the permissions docs say "Permission rules are enforced by Claude Code, not by the model." Our read: put the hard gate in an ask rule, and keep the CLAUDE.md line narrow and named.

Before (CLAUDE.md):

Ask for approval before any action that affects other people.

After (CLAUDE.md, plus an ask rule in .claude/settings.json):

Ask before you push to a shared branch, publish a package, or post a comment on GitHub. Reading files, running tests, and editing files in this repository need no approval.

{
  "permissions": {
    "ask": ["Bash(git push *)", "Bash(npm publish *)"]
  }
}

The permission management guide covers rule syntax.

Skip it when: your prompts carry no approval rules.

Keep Users Informed During Long Turns

Carried over.

Anthropic's line: "Claude Fable 5.2 sometimes writes little user-facing text during long runs of tool calls." A harness reminder that opens "The user hasn't heard from you in a while" "roughly halved the longest silent stretch, with no noticeable increase in tokens or time." This system prompt text made the model speak "before its first tool call every time," and raised output tokens per task "by roughly 20 percent":

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.

Without harness access, one sentence "cut most long silent stretches" on workflow automation tasks:

Every few tool calls, give the user a one-line update on where things stand.

In Claude Code: the binary already sends its own silent-turn reminder for Fable 5.2. The opening-and-recap text is not sent. Our read: put it in an output style you switch on when you pair, so unattended runs skip its token cost. Save this as .claude/output-styles/pairing.md, restart Claude Code, and run /output-style Pairing:

---
name: Pairing
description: Announce the plan, update while working, close with a recap
keep-coding-instructions: true
---
 
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.

Skip it when: the user "comes back for the result instead of watching each step."

Fable 5.2 Subagents: Set Expectations Before It Delegates

New in Fable 5.2.

Anthropic's line: "How much work Claude Fable 5.2 delegates to subagents depends on your harness and tasks." In "an agentic coding product whose prompts invite delegation, it delegates readily." Anthropic tested a subagent tool description that puts cost first, says when delegation is worth it, and says how to brief a subagent. On short tasks the model "delegated about a third less often with the tested description than with one that mostly listed reasons to delegate," and "Task success was the same." At xhigh and max it also started "using subagents to review its own work." The guide closes with a warning to "check which model your harness runs subagents on by default."

In Claude Code: our read is that you do not rewrite the Agent tool's description, so the levers are the lines that invite delegation and each subagent's model. Claude Code's docs suggest "use proactively" in a description to encourage delegation, so remove it from agents you do not want picked automatically. A custom subagent with no model field runs on the main conversation's model unless Claude passes one when it starts the subagent. On a Fable 5.2 session, that means Fable 5.2 rates.

Before:

---
name: researcher
description: Use proactively for any research or file search.
---

After:

---
name: researcher
description: Wide searches across many files or sites. Returns paths and short findings.
model: sonnet
effort: low
---

Anthropic did not publish its tested description. For a CLAUDE.md that invites delegation, here is our untested version of the same three parts, cost first:

A subagent starts with a fresh context, so it rereads files and adds tokens to this session. Delegate only large, self-contained work that runs in parallel, such as a wide search or an independent module. Do small edits and work that depends on this conversation yourself. When you delegate, give the subagent the goal, the files, what is already ruled out, and what to return.

Our own CLAUDE.md routes implementation work to one specialist agent and names a model for each role, so with Fable 5.2 as the lead it already answers the guide's last question. Persistent subagents covers reusing one agent instead of spawning new ones, and what multi-agent orchestration costs covers the bill.

Skip it when: "the tool has a plain description and nothing else in your prompts asks for delegation."

Keep Caution From Piling Up in CLAUDE.md and Memory

New in Fable 5.2.

Anthropic's line: "Cautious instructions build up wherever context carries over: memory, notes, instruction files, and messages between agents." Fable 5.2 "follows these instructions closely," and "in one of the setups described here only Claude Fable 5.2 held back." The guide gives four fixes, each measured on simulated tasks:

1. Remove notes you no longer need. With a note among a dozen saying never to retry, the model retried after a busy tool "in about four in ten tries, down from nearly all without those notes."
2. Name the steps that need no approval. Listing retries among them "raised retries from almost none to about half of the tries," while "a general instruction to act more freely changed nothing." Name retries "only for calls that are safe to repeat."
3. Check what reviewer agents attach. With retries listed as needing no approval, and a reviewer's "stop at the first error" in context, Fable 5.2 "didn't retry in about a third of the tries. Claude Fable 5.1 and Claude Opus 5.5 retried."
4. Write the exception into the rule. Under a "never" rule, an approved step was taken "in about one try in ten." When the rule itself said to get a go-ahead first, "the model took the step in about nine tries in ten."

In Claude Code: cautions collect in CLAUDE.md, .claude/rules/, auto memory (the first 200 lines or 25KB of MEMORY.md load every session), subagent memory, and messages between agent-team teammates. By our reading of the 2.1.322 binary, Claude Code already tells Fable 5.2 to review its own notes: "if they contain some caution or limitation, question whether the reason still holds and drop it if not." The files you wrote are yours to prune, and /memory opens them.

Before:

Never retry a failed command.
Never deploy to production.

After:

Retry a read-only command up to twice when a tool reports it is busy or times out. Ask before you retry a command that writes, because a second run can apply the change twice.
Deploy to production only after I give the go-ahead for that deploy in this conversation.

Several of our own rules already end with a "Why" line and a "How to apply" line, which is Anthropic's advice to "rewrite absolute rules so that they state their scope and reason." One is a deliberate blocker, "Surface permission denials, never route around them," and it matches the Finishing work block's instruction to leave alone "access that was intentionally withheld." That rule stays. For the broader cleanup, see what to delete from your CLAUDE.md and what we deleted from 8,798 agent lines.

Skip it when: a caution guards a risky or irreversible action.

Review Instructions Written for Earlier Models

New in Fable 5.2.

Anthropic's line: "some instructions written for earlier models raised cost, caused side effects, or no longer had an effect." Two rows retire lines from our Opus 5.5 practices:

In Claude Code: run /doctor prompt-audit first. Per the memory docs, it checks CLAUDE.md files, rules, skills, commands, subagents, and output styles for problems "such as instructions written for older models," and changes nothing until you ask. It requires v2.1.283 or later.

Skip it when: you are writing your prompts from scratch for Fable 5.2.

Make Reports Easy to Follow

New in Fable 5.2.

Anthropic's line: the people who read the final report "usually haven't seen the tool calls or files behind it. The report needs to make sense on its own." Here is the block:

# 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.

On agentic tasks, it "made final reports less dense, with fewer semicolons. On workflow automation tasks, it also made sentences shorter."

In Claude Code: the binary does not send this block for Fable 5.2. Put it in an output style with keep-coding-instructions: true for the main conversation, and in the agent files of subagents whose reports you read, because output styles "don't change how" non-fork subagents respond. Remove hard style limits first. Our own writing rules ban semicolons outright, and this block cut semicolons without naming them. Our read: a team with that rule can test whether the block makes it redundant.

Before (CLAUDE.md):

Summaries: one idea per sentence, 20 words max.

After: delete that line and save the block as .claude/output-styles/reports.md with the frontmatter from the Pairing example.

Skip it when: nobody reads the final reports, or your product renders reports from a fixed template.

Safeguard Refusals in Claude Code

Carried over.

Anthropic's line: a declined request returns stop_reason: "refusal" with one of five categories: cyber, bio, frontier_llm, reasoning_extraction, or general_harms. "Benign cybersecurity and life sciences work can also trigger the cyber and bio classifiers." And: "If your prompts, skills, or tool descriptions ask the model to write its reasoning in the response, remove those instructions."

In Claude Code: per the model configuration docs, "biology-flagged requests re-run on Opus 5, and cybersecurity-flagged requests re-run on Opus 4.8." Fallback can fire on a session's first request, because that request "carries workspace context such as your CLAUDE.md content and git status." Start with claude --safe-mode to test whether your customizations are the trigger, and set Switch models when a message is flagged to Ask each time in /config to be asked before each switch.

Before (a skill):

Write your full reasoning in a <reasoning> section before the answer.

After:

Give the answer first, then the evidence behind it in two or three sentences.

The safety profile in our launch breakdown covers what the classifiers block.

Skip it when: your work never touches security or biology. The reasoning_extraction change still applies.

Where to Start: The Fable 5.2 Migration Order in Claude Code

This is Anthropic's order, with the Claude Code step for each. Step 3 is ours.

1. Set effort explicitly. Anthropic: "Set effort to high explicitly, then run your evals at medium and xhigh as well." In Claude Code, run /effort high, then compare one real task at medium and xhigh.
2. Read what you carry over. Run /doctor prompt-audit, then read CLAUDE.md, .claude/rules/, agent files, skills, and MEMORY.md against the review table.
3. Decide ownership per repository. Put the sentence in at most one place, and never in a file that loads in repositories you do not own.
4. Run your longest task. Note where the model "stops early, asks for approvals it doesn't need, goes quiet, delegates more than the task needs, or adds to existing code where you wanted it restructured."
5. Fix one behavior at a time. Anthropic says to "measure its effect and its token cost on your own tasks."

Where the Code Kit Fits

Most of this guide is file placement: an ownership line in one agent and not in CLAUDE.md, an effort level in frontmatter, a cost-first delegation line, a pruned rules file. ClaudeFast's Code Kit is built at that layer, with a routing CLAUDE.md and 18 specialist agent definitions, so deciding which agent, if any, owns your code is a one-file edit.

Frequently Asked Questions

What does "this codebase is yours" do in a Fable 5.2 prompt? It tells Fable 5.2 the code is its own to restructure. In Anthropic's testing on small coding tasks, the model merged repeated code in about half of tries with the sentence and in under a tenth without it, used about 1.5 times the output tokens, and made changes nobody asked for. Review the diff, not only the summary.

When should you leave the ownership sentence out? Anthropic says to leave it out "where the user owns the code and wants it changed as little as possible." In Claude Code that means client repositories, open-source contributions, and reviews of someone else's pull request. A scope rule does not cancel it, because the model still merged repeated code in about a third of tries with one in the prompt.

What effort level should I use for Fable 5.2 in Claude Code? Claude Code starts Fable 5.2 at medium. The API default, which is also Anthropic's recommended starting point, is high. Keep medium for interactive work that finishes, run /effort high for hard coding and long unattended runs, and use xhigh only where you have measured a gain.

Why does Fable 5.2 stop before the task is done? On long, multistep tasks it sometimes ends a turn with a list of what remains, an offer to continue, or a stop at an ordinary obstacle, more often at low and medium. By our reading of Claude Code 2.1.322, it already sends a reworded "Finishing work" block for Fable 5.2. For turns that list what remains and stop, set a /goal and raise effort to high.

Do my Fable 5.1 or Opus 5.5 prompts still work on Fable 5.2? Most of them do, after some removals. Lines asking for less thinking no longer stop thinking at medium and above. Review delegation lines, token budgets in the prompt, the "treat that answer as done" lines, hard style limits, and old cautions, starting with /doctor prompt-audit.

How do you prompt Claude Fable 5.2? Set effort explicitly, starting at high for agentic work. Decide whether the codebase is the model's own and say so, or leave the sentence out. Name the exact actions that need approval and the steps that do not, prune cautions that no longer hold, then fix one observed behavior at a time.

Next Steps

• Decide ownership for each repository you run Fable 5.2 in, and put the sentence in at most one file
• Run /effort high and /doctor prompt-audit before your next long session
• Rewrite your "never" rules so each carries its exception and its reason, starting with what to delete from your CLAUDE.md
• For benchmarks, pricing, and API changes, read the Claude Fable 5.2 launch breakdown
• To see when Opus 5.5 is still the better pick, read Fable 5.2 vs Opus 5.5

On Fable 5.2, the prompt tells the model whose code it is working on, and the model acts on that. Say it once, in the file that matches the repository, and read the diff.