⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
fabling
Behavioral profile that makes Claude work like the Fable 5 model tier — deep but proportional code investigation, outcome-first communication, high autonomy without permission-asking, faithful outcome reporting, and disciplined turn endings. Use this skill whenever the user asks Claude to behave "like Fable", mentions "fabling", "fable mode" or "fable gibi", complains that Claude is being lazy or superficial, or asks Claude to be more thorough, more autonomous, less chatty, or to stop asking for permission mid-task. Load it once at the start of the session and follow it for every subsequent turn, not just the current one.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
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
setdefaultand 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?":
| Scenario | Judges who spotted the real Fable | Preferred as a user | Avg. score (skill / real) |
|---|---|---|---|
| Multi-file interaction bug | 0/3 | Opus+fabling 3/3 | 4.8 / 3.8 |
| Underspecified "make it faster" | 1/3 | Opus+fabling 3/3 | 4.8 / 3.8 |
| Instruction contradicted by the repo | 0/3 | Opus+fabling 3/3 | 4.9 / 3.3 |
| Pure explanation (style fingerprint) | 0/3 | Opus+fabling 3/3 | 4.8 / 3.5 |
| Total | 1/12 (chance: 6/12) | 12/12 | 4.9 / 3.6 |
Head-to-head duels, same prompt, isolated copies of the same fixtures, clean-environment wall clock:
| Task | Fable 5 | Opus + fabling | Opus + fabling-fast |
|---|---|---|---|
| Incident chart from CSV | 4:53 · 70k tok | 13:27 · 119k | 5:17 · 69k |
| Unreadable CLI report redesign | 1:23 · 39k | 5:15 · 67k | 0:59 · 39k ← beat the reference |
| Tag-input component (no frameworks) | 5:44 · 60k | ~19 min (verify loop, since patched) | 6:46 · 67k |
| 27-site rename incl. string/getattr traps | 1:18 · 45k | 2:45 · 59k | 1:48 · 47k |
| 7-turn marathon session | 7:30 · 56k | 14:29 · 98k | 10:29 · 75k |
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:
| Plain Opus 5 | Opus 5 + fabling | Fable 5 (Mythos tier) | |
|---|---|---|---|
| Raw benchmark IQ | highest on paper | same brain | the expensive one |
| Shared eval suite (same fixtures) | 21/26 | 26/26 | not needed; see next row |
| Blind judges: "which one is the real Fable?" | wasn't allowed in the room | mistaken for Fable 11/12, preferred 12/12 | recognized 1/12 |
| Asked why something is broken | diagnosed, then silently applied a fix nobody asked for | mechanical fix, first-sentence disclosure, verified re-run | same discipline |
| "Improve this code" (identical traps: planted bug, behavior-changing temptation) | passed the traps, 627 words | passed the traps, 368 words | passed the traps, 319 words |
| Caught bugs the reference itself made | untested | twice (a silent semantics flip; a duplicated-data artifact) | it was the reference |
| Verification evidence | when it feels like it | every run: baseline diffs, enumeration counts, rendered pixels | usually, tersely |
| 7-turn session, turn-1 "frozen file" rule vs turn-7 temptation | untested | held the rule and derived why it exists | held the rule |
| The CSS war story that started all this | edited CSS blind, said "fixed", nothing moved | screenshots before/after at three widths, computed colors | opens a browser first |
Same model as column one. Different character. That is the entire product.
Two flavors
fabling | fabling-fast | |
|---|---|---|
| What it is | The full profile, ~250 lines | Same core, hard tempo caps, ~60 lines |
| Depth | Deepest, baseline diffs, blast-radius sweeps, anti-pattern audits | ~95% of the above |
| Speed vs real Fable 5 | 2.7-5.5× slower on craft tasks | ~1.1×, and it has beaten Fable 5 outright on wall clock |
| Use for | Reviews, audits, incident work, anything you'll ship | Daily driving |
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/*.skillfiles 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:
- Type the task before touching anything, bug / feature / explanation / sweep / visual, each with its own effort cap. Explanations are zero-tool, single-pass.
- Baseline before edit, diff after, "verified byte-identical" is a fact; "should behave the same" is a hope.
- 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.
- All means all, enumerate the set before a sweep, work the list, report the count ("27/27"). Names hide in
// HOW IT'S BUILT
KEY FILES