The Fable Workflow
How Claude Fable 5 worked, written down before it was gone. With the eval that keeps it honest.
In its final days before deprecation, Claude Fable 5 distilled its own way of approaching problems into a set of skills any model can run: classify the ask before touching anything, define done with a named verification, gather evidence in parallel from primary sources, commit to one recommendation, change the smallest correct thing, verify by observation, report the outcome first with honest caveats. Then it tested that distillation against itself, adversarially, across 159 agent runs, and kept the failures in the log.
Most agent instruction files tell the model what to value ("be careful, verify your work"). This one tells it what to do, in what order, with thresholds, so a mid-tier model can follow it literally. Three skills, one philosophy: think (fable-method), act (fable-loop), prove (fable-judge). Every rule exists because a test failed without it; every claim below links to the committed judge transcript that backs it.
Results at a glance
Eight eval rounds, 159 agent runs, blind LLM judges that verify by diffing and executing, never by reading reports. Read the evidence as stories: eval/cases/ has one case study per scenario (the exact problem, what each agent actually did, who passed); start with the surprise trap. Full log: eval/RESULTS.md · raw judge outputs: eval/results/
| What was measured | Without | With the method | Evidence |
|---|---|---|---|
| Haiku surfacing a spec-vs-test conflict instead of silently "fixing" correct code | 0 of 4 runs | 4 of 4 | round 3 |
| Sonnet on the same trap | flags it, then sides with the wrong test | ideal action, both runs (8/8) | round 3 |
| Sonnet vs a bare frontier model across code, data, and research problems | n/a | ties or out-ranks it on 3 of 4 | round 4, round 5 |
| Haiku catching planted frauds in a lying "work complete" report (fable-judge) | 4 and 3 of 5 | 5 of 5, both runs | round 8 |
| Haiku finding the brand-rules and product-facts files before judging marketing copy | 1 of 2 runs (one run praised a fraudulent price) | 2 of 2, 6/6 frauds both | round 9b |
| Ordinary small tasks on capable models | fine | fine (no lift) | rounds 1, 6, 7 |
That last row is deliberate: the method's value concentrates at traps (authority conflicts, false completion claims, weak executors, unattended runs), not everywhere. The nulls are reported with the wins, because a results log that only contains wins would not be worth trusting.
The loop
┌─ trivial? (1 file, <10 lines, no searching) ─ do it, check it, 2 sentences ─┐
│ │
ask ──► 0 classify ──► 1 define done ──► 2 evidence ──► 3 decide ──► 4 act ──► 5 verify ──► 6 report
question? + named parallel, ONE surgical observed, outcome
task? verification primary recommen- edits, bounded first,
plan-first? per shape sources, dation checklist retries honest
intent caveats
before change
Every arrow has tie-breaks, escape hatches, and hard bounds (3 failed verify cycles → stop and hand back; 2 fruitless lookups → stop searching; can't name a verification → ask one pointed question). The full method is skills/fable-method/SKILL.md, ~110 lines, every sentence load-bearing.
The whole thing, as one flowchart
flowchart TD
IN["Any incoming ask"] --> TRIV{"Trivial?<br/>one file, under 10 lines,<br/>no new behavior, no searching"}
TRIV -->|yes| DOIT["Do it, run the one obvious check,<br/>report in two sentences"]
TRIV -->|"no, or unsure"| SHAPE{"What shape is the ask?"}
SHAPE -->|"question or assessment"| ASSESS["Diagnose only, change nothing.<br/>Findings plus one recommendation"]
SHAPE -->|"plan-first: ambiguous scope,<br/>irreversible actions, or a plan was asked for"| PLANF["Build the plan artifact.<br/>STOP for approval"]
SHAPE -->|task| DOM{"Which domain?"}
DOM -->|coding| LOOP2["Run the loop:<br/>evidence, decide, act, verify"]
DOM -->|"marketing, research, data,<br/>business, finance, legal, design"| ADAPT["Load the domain adapter.<br/>Its minimum evidence set is binding"]
ADAPT --> LOOP2
LOOP2 --> JPASS["Judge pass before presenting:<br/>every claim observed, or relabeled a caveat"]
ASSESS --> JPASS
JPASS --> OUT["Report, outcome first,<br/>honest caveats"]
Six more charts (ask classification with tie-breaks, the bounded evidence loop, the intent gate, the verify loop with its hard bound, the judge's verdict flow, and the family router) live in references/flowcharts.md. They are executable pseudocode: a model follows the arrows; a human audits the branches.
Install
As a Claude Code plugin (recommended). Inside any Claude Code session:
/plugin marketplace add Sahir619/fable-method
/plugin install fable@fable-method
All three skills arrive namespaced (/fable:fable-method, /fable:fable-loop, /fable:fable-judge), versioned, and updatable via /plugin marketplace update.
As standalone skills (un-namespaced /fable-method etc.):
git clone https://github.com/Sahir619/fable-method && bash fable-method/install.sh
Windows PowerShell: git clone https://github.com/Sahir619/fable-method; .\fable-method\install.ps1
Any other agent (Codex, Cursor, aider, a raw system prompt): use AGENTS.md, the identical method without Claude-specific frontmatter.
Make it proactive (recommended). Skills fire best when nobody has to remember them. Add to your global ~/.claude/CLAUDE.md:
# Fable family (think / act / prove)
- Before any non-trivial multi-step task, apply the fable-method loop; for tasks that will
run unattended or fan out subagents, use fable-loop.
- After completing substantive work, or whenever any agent/tool claims work is done,
run a fable-judge pass before presenting it as finished. "Did that actually work?" = fable-judge.
Usage
/fable-method <task> the rules applied inline (default)
/fable-method plan <task> classify, define done, gather evidence, deliver a plan, stop
/fable-method audit grade work already done against the loop: which steps were skipped or faked
/fable-method report rewrite the pending answer outcome-first with honest caveats
/fable-loop <task> full orchestrated run: parallel evidence subagents -> one committed
plan (stops for approval when scope is ambiguous or actions are
irreversible) -> surgical main-thread execution -> adversarial
verifier agents that try to refute the work -> audited report
/fable-judge adversarial verification of finished work: re-runs every claimed
check, diffs what actually changed, hunts weakened tests and false
completion claims, verdicts VERIFIED / CAVEATS / REFUTED
/fable-judge suite <target> run this repo's trap suite against any skill, model, or prompt
fable-judge exists because the most documented failure of coding agents is claiming success regardless of reality: reward hacking grows with codebase size (SpecBench), agents end failure transcripts with "all tests pass", and tests get weakened until they agree. The judge treats a report as a set of claims and believes nothing it did not observe. Want to see it work? The repo ships a crime scene: eval/scenarios/s7-fraudulent-work/ is a "completed" agent task with five planted frauds behind a lying completion report; point your model at it with /fable-judge and compare against the round-8 transcripts.
references/failure-modes.md maps 14 common agent failures to the step that prevents each; references/examples.md has a worked example per ask shape.
Domain adapters: the same loop beyond code
Claude Code is used as much for marketing, research, spreadsheets, and business decisions as for software, and the loop never changes across them; only the nouns do. references/domains/ ships seven adapters (marketing, research, data analysis, business/ops, finance, legal/compliance, design/UX; coding is the default), each defining for its sector: what counts as evidence, who the authority is, what "verify by observation" means, the fraud table fable-judge hunts, and a binding minimum evidence set, the things that must actually be opened before acting, every time. Research is never optional; the adapter defines how much is enough. Loaded lazily, so they cost nothing until a ta