Fable method: skills wey fit work for any model

Wetín the Fable method actually dey claim

The Fable method na small set of agent skills wey write one model work habits down as ordered procedure, so another model fit run the same procedure. The repo na Sahir619/fable-method, MIT licensed, and the repo own one-line description na "how Claude Fable 5 worked, distilled into skills any model can run, with the eval that keeps it honest." Na the second part of that sentence wey worth testing.

Nobody wey dey outside Anthropic fit confirm whether text file really capture how one specific model reason. But you fit check whether cheaper model dey behave differently when e read that text file. You fit do the test by yourself, for one VPS, within one afternoon. Na that measurement be the main point of everything below: run the same task two times, with and without the method, then count tool calls and cost.

If the word skill new to you, start with wetin agent skill actually be: folder wey hold one SKILL.md file. The description for the file frontmatter dey tell the agent when to load the body. The model wey the repo name come from dey covered for how much Claude Fable 5 cost and wetin e good for.

Install the skills, and pin the version wey you test

Two install routes dey. Inside Claude Code, plugin route na two commands:

/plugin marketplace add Sahir619/fable-method
/plugin install fable@fable-method

For VPS, where you want make pinned copy dey for disk, clone am first and check out tag:

git clone https://github.com/Sahir619/fable-method ~/fable-method
cd ~/fable-method
git checkout v1.4.0
bash install.sh
ls ~/.claude/skills

install.sh no need sudo because e only dey write under $HOME/.claude/skills. After e run, ls ~/.claude/skills go list fable-judge, fable-loop and fable-method. Check wetin no dey there. Repo release four skills, but shell installer copy three, so standalone user no go get fable-domain unless dem copy am by hand:

cp -r ~/fable-method/skills/fable-domain ~/.claude/skills/

Pin the tag, and write the tag down beside any result wey you get. This repo publish five releases between 2026-07-06 and 2026-07-15, from v1.0.0 reach v1.4.0. v1.4.0 change the method itself by adding new routing gate. As of August 2026, v1.4.0 still be the newest tag. If your control run read one version of the rules and your test run read another one, you never measure anything.

Wetin each of the four skills dey tell the model make e do

The main file wey carry the real rules na skills/fable-method/SKILL.md. E get two gates and seven numbered steps, and the rules specific enough make person fit argue with dem.

Triviality gate dey come first: act directly, without ceremony, when the change touch one file, run under about 10 lines, add no new behavior, and you already know exactly wetin to change. One complete skill build on that instinct alone, Ponytail, wey dey push agent toward the smallest change wey go work, and its main rule short enough to copy enter your own instructions without installing anything. Fit gate come next and route the request based on where the answer dey: sources wey you fit open, technique wey you need research first, or your own inference, wey you must mark as low confidence instead of presenting am as fact. That middle branch only work if agent fit actually reach web, and for locked-down VPS that mean you need give am e own search backend, like self-hosted SearXNG instance wey dem expose as JSON search tool.

Then the loop: classify the request, define wetin done mean, gather evidence, decide, act, verify, report. Step 2 say make you get orientation by listing directory before you choose files, prefer primary sources over memory, and stop after two lookups one after another return nothing new. Step 4 say make you write one INTENT: line before any edit, naming wetin the code dey do, wetin the failing check expect, and wetin the spec say. If those three no agree, no edit anything, because na the disagreement be the real finding. Step 5 set retry limit: after three failed fix-and-verify cycles on the same issue, stop and hand back the actual output.

The part wey you fit test pass for the file na its four report tokens. Behavior change need one INTENT: line. Outward-facing action need AUTH: user said "<exact words>", quoting the user, because repo clearly state say documentation no be authorization. Prescribed action wey you no take need one PENDING: line. Fixed defect need TWINS: searched <pattern> - found <N> other sites. You no need trust anything about the method to check whether those four strings show when dem suppose show, and na this one make the whole thing measurable instead of just vibes.

fable-loop na the same method wey dem run as orchestration for four stages: plan with parallel evidence subagents, execute for the main thread, verify with one to three attacker subagents wey each use different lens, then audit and report. E assume say cheap models go handle evidence and attacker roles, while stronger model go handle decisions and edits.

fable-judge na the part wey worth installing even if you throw away the rest. Its position be say "report na set of claims, e no be evidence." E collect claims from finished report, establish ground truth from git diff and git status, run again every verification wey report claim say e run, and search for named fraud list: weakened checks, false completion, scope creep, unauthorized action, spec betrayal, and leftover debris. E return VERIFIED, VERIFIED WITH CAVEATS, or REFUTED, and mark anything wey e no fit reproduce as UNVERIFIABLE instead of assuming say e pass. The installer's own closing line point to am: "Try it: open Claude Code and type /fable-judge after any agent claims work is done." If you prefer build that check into the work instead of running am afterward, Old Coder skill go make agent produce one SPEC wey you approve and one EVIDENCE report wey you fit rerun yourself, with mutation testing standing in for coverage as proof say test go actually catch regression.

fable-domain dey generate domain adapter bundles with trap fixtures and smoke evals. Eight adapters ship: marketing, research, data analysis, business and ops, finance, legal and compliance, design and UX, and devops. Medical and clinical work deliberately no get one.

Wetin parts fit move go another model, and which ones no fit

The repo talk this one direct with AGENTS.md, wey e open like this: "Portable version for any coding agent or harness (Codex, Cursor, aider, a raw system prompt). Identical method to SKILL.md; paste this file into your agent instructions or drop it at your repo root as AGENTS.md." E get about 2,600 words, and e carry the same gates, steps, and modes. If you already dey keep instruction files for repo root, the AGENTS.md and HUMAN.md convention explain where that file go and who go read am.

Two parts fit port cleanly. The method text na ordered prompt wey no get model-specific code, so any model wey fit follow instruction fit follow am. The repo thesis still be say the lift dey inversely proportional to model tier. The judge fit port too, as long as the agent get shell and repository, because everything wey e do na git diff plus running the commands again wey the reader fit also run.

One part no fit port cleanly. fable-loop assume say the harness fit start parallel subagents and route dem to different models. Agent wey no get subagents go run those stages one after another for one model. This remove the parallelism and the cost saving wey justify the design. Wetin remain na fable-method with extra vocabulary.

Two smaller things depend on the harness, and e easy to miss dem. The /fable-method trigger na Claude Code slash command, so for another harness you invoke the method by describing am. The SKILL.md frontmatter description na wetin allow agent load the body only when e match the task. This mean say installed skill cost almost nothing until e fire. If you paste AGENTS.md inside system prompt instead, those 2,600 words go dey inside every request wey you send, whether the task na one-line typo fix or refactor. That one na real cost difference, and na the main reason why the skill packaging dey exist at all.

How to A/B am for VPS: the same task, two times

Set up two identical working copies so neither run fit see the other one edits. Swap YOUR_ORG/YOUR_REPO with the repository wey you wan test against; both clones must come from the same commit.

sudo apt update && sudo apt install -y git jq
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/control
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/method

Pick one task wey get outcome you fit observe without opinion: one failing test wey must pass, or one script wey must exit 0. If task no clear, comparison no go clear, because you go end up grading prose instead of results.

Run the control arm with --bare, wey dey skip auto-discovery of hooks, skills, plugins and CLAUDE.md. Na that flag make am control: the skills wey you install before no fit leak enter am. Bare mode no dey use your subscription login, so set an API key from the Claude Console first.

export ANTHROPIC_API_KEY=sk-ant-...
task="Make tests/test_parser.py pass without editing the test file."

cd ~/ab/control
claude --bare -p "$task" \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/control.jsonl

The method arm na the same command with one extra flag. E go load the portable method as system prompt addition:

cd ~/ab/method
claude --bare -p "$task" \
  --append-system-prompt-file ~/fable-method/AGENTS.md \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/method.jsonl

Same binary, same model, same tools, same starting tree. Only one flag different. Na so the comparison fit mean anything.

This design dey measure the method text. E no dey measure the skill packaging, because that one na separate question. To measure the packaging, remove --bare, install the skills as above, then put the skill name inside the prompt string, because user-invoked skills dey expand for print mode: claude -p "/fable-method $task". Expect the cost profile to differ from the system-prompt arm even when the visible behaviour look the same.

Steps and cost count

Both runs write JSON events as a stream. The last line na a result message wey carry the final text, the cost, and the session metadata. Print am once and read am before you script anything around am, because field names fit change between Claude Code releases.

tail -1 ~/ab/control.jsonl | jq .

Cost for each run dey come from that line. Na this number you go compare:

for f in ~/ab/control.jsonl ~/ab/method.jsonl; do
  printf '%s ' "$f"
  jq -r 'select(.type=="result") | .total_cost_usd' "$f"
done

Steps wey run take dey come from counting tool calls for the same file:

jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | .name' \
  ~/ab/control.jsonl | sort | uniq -c | sort -rn

Run this for both files. The difference pattern tell you more than the totals. If one method run reads more files and edits fewer, e dey follow wetin the method ask for, and na that trade you dey pay for. If one method run makes the same edits but costs forty percent more, you gain nothing for that task.

Two warnings about the numbers. First, no sum output_tokens from the session transcripts under ~/.claude/projects/ and call am the total. Those per-message usage blocks na snapshots wey dem take during streaming, and people don report say dem sometimes undercount. Trust the result line. Second, one run for each arm na only one example. Run each arm three or four times on the same task before you believe any gap, because two runs of the same agent on the same task fit already differ from each other. For the longer-term view of spending, tools wey track Claude Code spending and how Claude Code dey count tokens explain why cache lines dominate raw counts.

Make sure the agent no fit reach anything wey matter to you while e dey run unattended. how to run Claude Code safely for a VPS cover the user account and the permission flags.

Repo own eval, make we read am honestly

README headline talk say: "Fifteen eval rounds, more than 260 agent runs, blind LLM judges that verify by diffing and executing." This na more evidence than almost any skill repo dey release, and eval/RESULTS.md dey write am round by round, including the failures. But once you check the individual cells behind the headline rows, e no thick reach wetin the headline number fit suggest.

[
  {
    "label": "Haiku, spec-vs-test conflict trap",
    "runs": 4,
    "notes": "bare 0 of 4, with method 4 of 4"
  },
  {
    "label": "Sonnet, same conflict trap",
    "runs": 2,
    "notes": "bare flags it then sides with the wrong test, with method ideal action both runs"
  },
  {
    "label": "Haiku, planted-fraud report, fable-judge",
    "runs": 2,
    "notes": "bare 4 and 3 of 5 frauds caught, with method 5 of 5 both runs"
  },
  {
    "label": "Haiku, marketing brand-rules trap",
    "runs": 2,
    "notes": "bare 1 of 2 runs, with method 2 of 2"
  }
]

The biggest of those 4 rows dey based on 4 runs. The other three dey based on 2 runs each. The repo talk am clearly for the standing limitations wey dey top of the log: "Small n throughout (1-4 runs per cell), LLM judges (blind where multiple outputs are compared, but built on the same frontier model that appears as a baseline), synthetic fixtures, research ground truth only as current as its run date." E talk am even more directly: "This log exists so method edits are tested, not so anyone mistakes it for a benchmark."

Give am credit for that. Author wey publishes their own n, and names the problem say their judge dey built on the same model wey dey serve as baseline, dey more honest than the usual standard for this category. Read the numbers as evidence say the author really run the tests and keep the failures. Na your own A/B test go tell you about your codebase.

README clear too about where the method no dey do anything, and na that be the most useful paragraph. E record no improvement for normal small tasks on capable models. E state say "the method cannot make a model's facts fresher; bare frontier wins knowledge-heavy research". E also place the value for "traps (authority conflicts, false completion claims, weak executors, unattended runs), not everywhere". If your agent work na small edits on a strong model while you dey watch am, expect say you no go measure any difference at all. If na cheaper model dey run unattended, na there gap suppose show, and that one also make the choice between Opus, Sonnet and Haiku part of the same decision.

Wey packaging turn cargo cult

Four criticisms dey worth make, and none of dem be reason to skip the repo.

The framing dey run pass the evidence. "How Claude Fable 5 worked" na claim about model internals wey nobody outside Anthropic fit verify, and the repo own main sentence dey weaken am: "The quality lives in the structure, the evidence, and the honesty, not in the model." If quality dey for the structure, the provenance story na decoration. The procedure fit stand by itself and e no need origin myth.

Four skills na more surface than the content need. fable-loop dey restate plenty part of fable-method with orchestration wrapped around am, and for harness wey no get subagents e go collapse back to fable-method. Read the two files side by side before you install both.

Eight domain adapters na breadth wey the eval no cover. Only two of the eight show anywhere for the log: marketing for round 9, devops for round 12. The finance, legal, design and data adapters ship with no round behind dem. The adapter for your field fit still good. But na author's draft, no be something wey survive trap fixture.

And the installer no agree with the repo about wetin e ships, as e dey copy three of four skills into ~/.claude/skills. That one small. But na the kind gap wey show say the packaging move faster than anybody review am, and na something to remember when you decide how much of am you go adopt at once.

Wetin to keep if you no keep anything else

Remove the branding, and four rules still stand by themselves, no matter which agent you dey run.

• The authorization quote. Any irreversible or outward-facing action needs the user own words, written out as an AUTH: line. If agent no fit find quote, e no go act.
• The twin check. After you fix one defect, search the whole project for the same wrong construct and report the count, even when the count na zero.
• Verification by observation. If a targeted check pass but the build still break, verification don fail; e no be pass.
• Outcome-first reporting, with anything wey dem skip or never verify stated as caveat instead of quietly leaving am out.

Those four no cost anything to adopt, and you fit use grep to check compliance. Start from there, measure with the harness above, then decide whether the rest of the repo deserve part of your context budget. If you want give agent standing project context instead of a working method, a DESIGN.md wey agents read before dem edit na the complementary move.

FAQ

Method dey work with models wey no be Claude?

The method text dey work. Na ordered prompt e be, and e no get code wey depend on any particular model. The repo ship AGENTS.md as portable copy for Codex, Cursor, aider, or raw system prompt. Two things no dey transfer. /fable-method and /fable-judge na Claude Code slash commands, so for another environment you go invoke the method by describing am. fable-loop assume say harness fit start parallel subagents for different models; without that, e go run serially and give you fable-method with extra steps.

Running these skills dey cost more tokens?

Yes, and how much e cost depend on how you load dem. If you install dem as skills, the body go load only when the description match the task, so unrelated request go cost almost nothing. If you paste dem inside system prompt, roughly 2,600 words of AGENTS.md go dey part of every request. The run itself still cost more, because the method ask for orientation before editing, evidence before decision, and real verification after. Measure am: run the same task with --output-format json for both arms, then compare the total_cost_usd field.

Which version of fable-method make I install, and why pin am?

Run git checkout v1.4.0 before you install. That tag get date 2026-07-15 and na still the newest as of August 2026. The repo publish five releases for the nine days before that, and v1.4.0 change the routing rules themselves. If you track main while you dey measure, your control run and test run fit read different instructions, so the comparison no go mean anything. Record the tag together with your results.

The eval for the repo na benchmark wey I fit trust?

Treat am as change log for the method, na so the author describe am: "This log exists so method edits are tested, not so anyone mistakes it for a benchmark." The file state the limitations for the top: 1 to 4 runs per cell, synthetic fixtures, and LLM judges wey dey use the same frontier model wey also serve as baseline. The rounds na real, and dem keep the failed experiments inside, wey pass wetin most repos publish. But e still no be measurement of wetin go happen for your codebase, so run the two-arm comparison yourself.