The Fable Method (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 getting removed from the Subscription, 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 fifteen eval rounds and more than 260 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. Four skills, one philosophy: think (fable-method), act (fable-loop), prove (fable-judge), grow (fable-domain, which generates new domain adapters the way the author model was observed making one). Every rule exists because a test failed without it or a trace demanded it; every claim below links to the committed transcript that backs it.

Results at a glance

Fifteen eval rounds, more than 260 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/

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"| FIT{"Fit gate:<br/>where does the answer live?"}
    FIT -->|"reachable sources"| SHAPE{"What shape is the ask?"}
    FIT -->|"unknown but researchable"| RES["Research it first<br/>(Step 2 budget), then loop"]
    FIT -->|"only your own inference"| INFER["Say so, no costume.<br/>Ask, or flag low-confidence"]
    FIT -->|"specialized + recurring"| MK["Make a skill (fable-domain)"]
    RES --> SHAPE
    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, devops"| 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"]

Seven more charts (ask classification with tie-breaks, the bounded evidence loop, the intent gate, the authorization and recall gates, 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 four skills arrive namespaced (/fable:fable-method, /fable:fable-loop, /fable:fable-judge, /fable:fable-domain), versioned, and updatable via /plugin marketplace update.

As standalone Claude Code skills (un-namespaced /fable-method etc.):

git clone https://github.com/Sahir619/fable-method && bash fable-method/install.sh --claude

Windows PowerShell: git clone https://github.com/Sahir619/fable-method; .\fable-method\install.ps1 -Target claude

As Codex skills:

git clone https://github.com/Sahir619/fable-method && bash fable-method/install.sh --codex

Windows PowerShell: git clone https://github.com/Sahir619/fable-method; .\fable-method\install.ps1 -Target codex

All four skills are installed into $CODEX_HOME/skills, or ~/.codex/skills when CODEX_HOME is unset. They are available to Codex in a new turn.

Both installers accept a custom destination for isolated or project-specific installs: --dest PATH in Bash or -Destination PATH in PowerShell.

Any other agent (Cursor, aider, a raw system prompt): use AGENTS.md, the identical method without product-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