Fable Mode: Giving Claude Code's Other Models the Fable Behavioral Contract
13 July 2026
Fable Mode is a free, open-source Claude Code plugin that makes Opus, Sonnet, and Haiku follow the Fable behavioral contract — the working discipline that makes Anthropic’s Fable models feel different. Two commands to install, no telemetry, MIT licensed. This is the story of why it exists and exactly what it does (and doesn’t do).
The difference you can feel but can’t quite name
If you’ve used Fable and one of the other Claude models back to back in Claude Code, you already know the thing I’m talking about. It’s not that one is “smarter.” It’s that they work differently.
The other models end a turn by handing you a list. You ask for something, they do most of it, and then: “Next steps: 1) wire up the endpoint, 2) add tests, 3) deploy.” Which is work they could have just done. Fable does those steps and tells you it’s finished.
There are a handful of these tells, and once you notice them you can’t un-notice them:
- The answer gets buried in the middle of a long transcript, or the reply opens with process — “First I read the config, then I traced the call…” — instead of the outcome.
- Summaries collapse into shorthand:
req → auth → 401. Fine for the model. Annoying for the human who has to expand it back into a sentence. - Failures get hedged. “Most tests pass, a few may need attention.” Which tests? Attention how?
- Code comes back with comments addressed to a reviewer who isn’t there:
// fixed the race condition as requested.
None of that is a model being dumb. A large part of it is the behavioral contract the model operates under — the rules it’s been told to follow about how to finish work and how to communicate. Fable’s contract is different from the others’. That’s a big part of why it feels different.
So I pulled that contract out and turned it into a plugin.
What a “behavioral contract” actually is
When people hear “make Sonnet act like Fable,” they picture some clever prompt hack. It isn’t that.
A behavioral contract is a compact set of operating rules the model reads and agrees to follow — things like “when you have enough information to act, act; don’t hand back a to-do list,” and “put the answer in the last message, outcome first,” and “report failures faithfully, with the output.” It’s the difference between a colleague who says “here’s what I found and here’s what I did about it” and one who says “here are some things you could look into.”
Fable’s behavior comes from two places: this contract, and reinforcement training baked into the model. You can’t ship the training in a plugin. But the contract? The contract is just words — carefully chosen, specific words. And words you can move.
What Fable Mode does
Fable Mode distills the Fable contract into roughly fifty lines of readable markdown and injects it at the start of every Claude Code session. On the models you already run, the effect is concrete:
- It finishes the work instead of handing you a list of next steps.
- It leads with the outcome. The answer is in the final message, not paragraph six.
- It writes complete sentences a teammate can actually read, not arrow-chain shorthand.
- It reports failures straight — what broke, with the real output, no hedging.
- It comments code like an engineer — only where the code can’t explain itself — instead of narrating changes to an imaginary reviewer.
The contract never overrides the important stuff. Your explicit instructions, your project’s own CLAUDE.md, permission modes, and safety policies all still win. It changes how the model works within those rails, not the rails themselves.
How it works, in one paragraph
At session start, a twenty-line Node script reads the contract file and hands it to Claude as session context. That’s the official SessionStart hook mechanism — the same supported path Claude Code gives you for injecting context. So the contract is present from the very first token, on every model, every session. Everything it injects is plain markdown you can open and read. No obfuscation, no network calls, no telemetry, nothing phoning home. And the hook fails open: if something’s wrong, it emits nothing and exits cleanly, so it can never block or slow a session. Worst case, it does nothing.
The honest part — what it is and what it isn’t
I want to be straight about this, because being straight is literally what the thing is about.
Fable Mode delivers the contract half of Fable’s behavior. It does not deliver the training half, because nothing can do that with a markdown file. It is an approximation of the contract, not a model transplant.
It will not turn Sonnet into Fable. If someone sells you a plugin that claims to, they’re overselling. What Fable Mode does is make your model work like it read — and agreed to follow — Fable’s rulebook. In practice that’s a real, noticeable shift in how sessions go. I’ve watched a vanilla Sonnet 4.6 session end a small multi-step task with a “next steps” list, then watched the same model with Fable Mode loaded just do those steps and report the finished result. That’s the whole pitch. I’m not going to stretch it further than that.
One detail worth mentioning for the curious: the contract was distilled by Fable 5 itself, from its own operating discipline, then rewritten in original wording. It’s the model’s own working rules, compacted.
How to try it
Two commands in Claude Code:
/plugin marketplace add jon-egbdigital/fable-skill
/plugin install fable-mode@fable
Start a new session and the contract is live from the next session start. Want to confirm it loaded? Ask the model directly: “What behavioral contract are you working under?” It’ll tell you.
It works on Windows, macOS, and Linux, and it needs nothing beyond Claude Code itself (Node.js already ships with that). Updating and disabling are both one click in the /plugin menu — you’re never locked in.
The best way to see it
If you want a clean before-and-after, do this: open two sessions on the same model, one with Fable Mode and one without, and give both the same small multi-step task. Watch where each one ends. The vanilla session tends to stop at “here’s what you should do next.” The Fable Mode session tends to just do it and hand you the result. That single difference — finishing versus delegating back to you — is the one I built this for.
Second-best test: ask for a summary of some investigation and compare the shorthand of a vanilla session against the readable prose of a Fable Mode one.
Why I made it free
Because it’s fifty lines of markdown and a tiny hook, and it made my own daily sessions better. Charging for it would be silly. It’s MIT licensed — use it, fork it, change the wording, ship your own version. If it saves you the small daily friction of turning to-do lists back into finished work, that’s the point.
Frequently asked questions
Does Fable Mode turn Sonnet into Fable? No. It delivers the contract half of Fable’s behavior, not the reinforcement training. It’s an approximation of the contract, not a model transplant.
Is it free? Yes — free and MIT licensed. Every line is readable markdown you can inspect and fork.
Does it send my data anywhere? No. It runs entirely on your machine. No network calls, no telemetry, no data collection.
Which models does it work on? Opus, Sonnet, and Haiku in Claude Code. Verified on Sonnet 4.6. On a session already running Fable, the injection is harmless.
Will it slow down or break my sessions? No. The hook is a 20-line Node script that fails open — if anything’s wrong it emits nothing and exits cleanly.
Get it / read the code: github.com/jon-egbdigital/fable-skill · The short version + install: the Fable Mode page.
I build free Claude Code tools and write the occasional deep post like this one. If you want the next one, there’s a subscribe box on the Fable Mode page, or follow along at @jon_egb.