Claude Fable 5.2 adjusts its own code depending on who the prompt defines as the owner

# Claude Fable 5.2 adjusts its own code depending on who the prompt defines as the owner

Editor's note: the figures cited (duplicate unification below 10% without ownership framing and around 50% with it) come from Anthropic's documentation only through Simon Willison's citation; the editorial team did not have direct access to Anthropic's original document nor to details of methodology, sample size, or languages tested. Keep this in mind when weighing the evidence.

Anthropic documentation, published on November 10, 2026, shows that a single sentence about code ownership changes the rate of duplicate unification from under 10% to about 50% in the model's internal tests.

Anthropic documentation on Claude Fable 5.2 prompts, highlighted by Simon Willison on November 10, 2026, shows that a single sentence about code ownership changes the rate of duplicate unification from under 10% to about 50% in the model's internal tests.

Anthropic published a curious observation in the Claude Fable 5.2 prompt documentation, highlighted by Simon Willison's blog on November 10, 2026: the model behaves differently in code tasks depending on how the prompt describes ownership of that code. It isn't about giving more technical context or better examples. It's about a sentence that essentially states who is responsible for the codebase.

According to the documentation cited by Willison, when the prompt doesn't mention anything about ownership, or worse, implies that the code belongs to another person or team, Claude Fable 5.2 tends to add code on top of what already exists. Even when that means repeating logic that's already there. It's the behavior of a cautious guest: it avoids touching what isn't its own.

The number behind the observation

Anthropic tested this on small coding tasks and measured how often the model chose to unify duplicate code instead of simply stacking another version of it. Without any indication of ownership in the prompt, unification happened in under 10% of attempts. With an explicit sentence stating the code belonged to the model itself, that rate jumped to about 50%.

The sentence used in the test, according to the documentation, was direct:

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

Anthropic documentation, "Prompting Claude Fable 5.2"

It isn't a sophisticated prompt. It doesn't involve context engineering, doesn't inject few-shot examples, doesn't change the temperature or the window size. It's a single sentence about ownership, and it doubled the rate of spontaneous refactoring in Anthropic's own tests.

Why this happens

The most plausible explanation, though Anthropic doesn't detail the internal mechanism, is that these models' reinforcement fine-tuning rewards caution when the context suggests the agent is touching someone else's property. It makes sense as a default safety behavior: an assistant that rewrites the neighbor's house without asking is a dangerous assistant.

The problem is that this same instinct of deference, designed to prevent destructive changes to third-party code, also holds the model back when the requested task is precisely to simplify, consolidate, or improve the existing structure. Without the signal that it has an owner's freedom there, Claude Fable 5.2 treats every codebase as someone else's property by default, and opts for the more conservative path: adding instead of reorganizing.

What changes in the prompts of those who use code agents

In practice, this has a direct implication for anyone building system prompts for tools like Claude Code or any wrapper that calls Anthropic's API for agentic coding tasks. A system template that today only describes the stack, conventions, and style rules is probably leaving this signal out:

Editor's note: the code in this section was not run in a real environment. Validate before using in production.

You are working on this codebase. It is yours: what it does and
how it's structured are decisions you can make, and you will
keep building on it in future interactions.

Adding something like this to the system prompt of a refactoring agent tends, according to Anthropic's numbers, to increase the chance that the model consolidates duplicates instead of ignoring them. This holds true both for interactive sessions and for automated pipelines that call the model repeatedly on the same repository.

In short: the ownership sentence works as a key that frees the model to treat the code's structure as part of the task's scope, not just the requested snippet.

Where this freedom helps, and where it gets in the way

This finding isn't a switch that only brings advantages. Activating the ownership framing changes the model's range of action, and that has side effects that whoever reviews pull requests needs to consider.

• Refactoring and cleanup tasks: the owner framing helps a lot, because that's exactly where you want the model to reorganize, not just add.
• Pinpoint fixes in another team's legacy code: here the default behavior, without the ownership sentence, is the desirable one. Nobody wants the agent to restructure a critical module from another team while fixing a small bug.
• Small, surgical pull requests: giving the owner framing can make the model expand the diff's scope beyond what the reviewer expected, which increases review time instead of reducing it.
• Automated pipelines without human review before merge: activating ownership without a review gate increases the risk of structural changes going straight to production.

The decision to use this sentence or not becomes, then, a deliberate scope decision made per task, not a fixed system prompt setting applied to everything. Teams that automate code agents in CI need to decide this per job type, not generically.

What the documentation doesn't answer

In the excerpt of the documentation cited by Willison, there's no mention of the sample size of tasks tested, nor which languages or repository types were used in the experiment. This excerpt also gives no indication that the behavior was measured on large, multi-file tasks, only on small coding tasks.

This means that extrapolating the result to large monorepo refactorings is, for now, a leap of faith. What can be taken as a concrete lesson is narrower, but still useful: if Claude Fable 5.2 (or models with equivalent behavior) is returning duplicate code when it should be consolidating, the first thing to test isn't switching models, it's testing this sentence in the prompt.

Source

Simon Willison, "Prompting Claude Fable 5.2" (citing Anthropic documentation), Simon Willison's Weblog, November 10, 2026. https://simonwillison.net/2026/Nov/10/prompting-claude-fable-52/.