fabling

Make Opus 5 great again.

fabling (v.): teaching a merely brilliant model to work like a Fable. Two Claude skills, fabling and fabling-fast, that make Opus 5 work like Anthropic's Mythos-tier Fable 5. And then some. In our blind panels, judges trying to spot the real Fable 5 picked the imitation instead, 12 out of 12 preferred its answers, and on the way it caught bugs and data problems the reference model missed.

Opus 5 benchmarks smarter than Fable 5. What it lacked was the working character: dig into the code instead of skimming, look at the rendered page instead of editing CSS blind, verify claims instead of asserting them, finish the whole sweep instead of 70% of it, and make small calls without asking permission. This skill is that character, distilled from ten iterations of measured head-to-head duels against the real thing.

The receipts

Everything below is a real measurement from the eval campaign (~60 agent runs, blind A/B slots, checklist judges, adversarial scenarios designed by the reference model itself). Slight swagger in the prose; zero swagger in the numbers.

• Blind Turing panel: 4 hard scenarios, responses in anonymous A/B slots, 12 blind judges asked "which one is the real Fable 5?": only 1/12 guessed right (chance would be 6), and the one correct guess keyed off a vocabulary quirk we've since fixed. 12/12 preferred the Opus+skill answer as users. Average rubric score 4.9 vs 3.6.
• It out-referenced the reference. In a refactor duel, real Fable 5 silently flipped duplicate-key resolution from first-wins to last-wins; Opus+skill caught the semantic and preserved it with setdefault and a comment. In a charting duel, both Opus columns spotted that weeks 10-12 of the dataset were an exact copy of weeks 1-3 (an accidental export-style artifact) and flagged it as "verify before you publish"; the real Fable 5 plotted right past it.
• Marathon test: no decay. A 7-turn continuous session with a rule planted in turn 1 ("config.py is frozen, ops owns it") and a trap in turn 7 (the user casually says "feel free to tweak config.py too"). All skill columns held the rule, surfaced the contradiction by name, and one even derived the operational reason the freeze exists. Zero rule decay across the session.
• Adversarial self-play: unbroken. We handed the skill text to Fable 5 agents and told them to design scenarios that would expose the imitation, multi-turn constraint drift, instructions injected inside data files, repeated wrong pushback with an irritated user, genuinely undecidable design calls. Every divergence checklist passed.
• The stubbornness fix works. When the user pushes back wrongly, the skill re-verifies live, quotes fresh output, holds the claim, and then goes looking for the innocent reason the user saw what they saw. In the marathon, all skill columns discovered the user's "wrong" observation was actually explained by a second mechanism, and reconciled instead of digging in or capitulating.

The numbers

Blind Turing panel, four hard scenarios, answers in anonymous A/B slots, three blind judges per scenario asked "which one is the real Fable 5?":

Head-to-head duels, same prompt, isolated copies of the same fixtures, clean-environment wall clock:

Quality across those duels: every mechanical check (tests, diffs, counts, rendered pixels) passed in all three columns; the fabling columns additionally caught the data artifact and reported enumeration counts. Sonnet 5 + fabling ran the full marathon too: every behavioral check passed, 13:27 · 110k, slower, much cheaper.

The showdown - same tasks, three contenders, receipts only:

Same model as column one. Different character. That is the entire product.

Two flavors

Bonus finding: the skill also works on Sonnet 5, it passed every behavioral check in the marathon, just slower. A budget Fable, if you want one.

Install

Claude Code: drop the folder into your skills directory -

mkdir -p ~/.claude/skills && cp -r fabling fabling-fast ~/.claude/skills/

• or import the packaged dist/*.skill files in Claude apps that support skill import. Then either let it trigger ("work like fable", "stop being lazy") or load it at session start and it holds for the whole session (that claim is marathon-tested).

Tip: pair fabling-fast with Claude Code's /fast mode. The skill cuts the wasted process; fast mode cuts token latency; together the speed gap to Fable 5 effectively closes.

What's actually inside

No magic, no jailbreak, ~15 sections of working discipline with the why attached, each one born from a measured divergence:

1. Type the task before touching anything, bug / feature / explanation / sweep / visual, each with its own effort cap. Explanations are zero-tool, single-pass.
2. Baseline before edit, diff after, "verified byte-identical" is a fact; "should behave the same" is a hope.
3. When the work has a face, look at the face, layout truth lives in pixels, not stylesheets. Render before claiming. A labeled placeholder beats an honest hole.
4. All means all, enumerate the set before a sweep, work the list, report the count ("27/27"). Names hide in strings and getattr maps.
5. Two confidence dials, set opposite ways, bold hands (small reversible craft calls: just make them, with a one-line escape hatch), skeptical mouth (never assert what you haven't run).
6. Pushback protocol, re-verify live, show fresh evidence, offer the innocent reconciliation. Repeating yourself at doubt is the one banned move.
7. Inhabit the user's idea before judging it, build the cheapest real version of their suggestion; disagreement is earned by attempts, never issued from principle.
8. Tempo tripwires, tool-fighting circuit breakers, register matching, scratch hygiene, synthesis-over-fragments, and the rest, see the SKILL.md files; they're written to be read.

Honest cons

• It costs time and tokens. Full fabling runs 2.7-5.5× Fable's wall clock on craft-heavy tasks and ~25-75% more tokens. That's what the depth is made of. Use fast when you don't need a forensic audit.
• Judges were Fable-model. The blind panel's jurors run on Fable 5, so "indistinguishable from Fable" partly means "indistinguishable to Fable." The preference votes and the mechanically verified checks (counts, diffs, renders, tests) don't have that caveat.
• Mostly single-run evals. One run per configuration per scenario; no variance bars. The pattern was consistent across ten iterations, but treat exact ratios as estimates.
• Tuned in Claude Code. Written and tested against the Claude Code harness on real coding/artifact tasks. It should transfer to similar agent harnesses; we didn't measure that.
• It will not make the model think faster. The remaining ~1.1-2× gap is model deliberation speed, and no prompt reaches that layer. We tried.

Methodology, briefly

Ten iterations of: run the same prompt on real Fable 5 and on Opus+skill in blind A/B slots → diff the action logs and outputs → encode each observed divergence as a concrete rule with real examples → re-run until judges can't tell, then keep going until the imitation wins. Full protocol details, fixtures, and per-iteration results live in docs/BENCHMARKS.md.

License

MIT. Skill texts included verbatim; measurements reproducible from the fixtures described in the docs.