Fable method: agent skills for any model

Wetin the Fable method actually claim

The Fable method na small set of agent skills wey write one model's working habits down as an ordered procedure, so another model fit run the same procedure. The repo na Sahir619/fable-method, e get MIT license, 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 half of that sentence be the claim wey worth testing.

Whether text file really capture how one specific model think no be something anybody outside Anthropic fit check. But whether cheaper model go behave differently when e read that text file na something you fit check by yourself, for one VPS, within 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 an agent skill actually be: na folder wey hold one SKILL.md file, and the frontmatter description inside am tell the agent when to load the body. The model wey 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 you test

There are two install routes. Inside Claude Code, the plugin route is two commands:

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

On a VPS, where you want a pinned copy on disk, clone and check out a tag first:

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 dey write only under $HOME/.claude/skills. After e run, ls ~/.claude/skills dey list fable-judge, fable-loop and fable-method. Check wetin no dey there. The repo release four skills, but the shell installer copy three, so standalone user no 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 no measure anything.

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

The file wey carry the main weight na skills/fable-method/SKILL.md. E get two gates and seven numbered steps, and e rules specific enough to argue with.

Triviality gate dey come first: act directly, without ceremony, when the change touch one file, run under about 10 lines, add no new behaviour, and you already know exactly wetin to change. One complete skill dey built on this instinct alone, Ponytail, wey dey push agent toward the smallest change wey go work, and e core rule short enough to copy enter your own instructions without installing anything. Fit gate dey follow, and e 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 the agent fit actually reach web. For locked-down VPS, this mean say you need give am e own search backend, such as self-hosted SearXNG instance wey you expose as JSON search tool.

Then the loop: classify the request, define wetin done mean, gather evidence, decide, act, verify, report. Step 2 talk say make you first orient yourself by listing the directory before you pick files, prefer primary sources instead of memory, and stop after two consecutive lookups wey return nothing new. Step 4 talk say make you write one INTENT: line before any edit. The line must name wetin the code dey do, wetin the failing check expect, and wetin the spec talk. Make you no edit at all when those three no agree, because na that disagreement be the real finding. Step 5 limit retries: after three failed fix-and-verify cycles on the same issue, stop and return the actual output.

The part of the file wey you fit test most easily na e four report tokens. Behaviour change must get INTENT: line. Any outward-facing action must get AUTH: user said "<exact words>", and you must quote the user, because the repo clearly talk say documentation no be authorization. Any prescribed action wey you no take must get PENDING: line. Fixed defect must get 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. Na this make the whole thing measurable instead of just vibes.

fable-loop na the same method wey 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 worth installing even if you throw away the rest. E position be say “report na set of claims, e no be evidence.” E collect the claims from finished report, establish ground truth from git diff and git status, run again every verification wey the report 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 own final line point to am: “Try it: open Claude Code and type /fable-judge after any agent claims work is done.”

fable-domain dey generate domain adapter bundles with trap fixtures and smoke evals. Eight adapters dey 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.

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

The repo answer this one directly with AGENTS.md, wey e open with: "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 move 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 move too, as long as the agent get shell and repository, because everything e dey do na git diff plus to run commands again wey the reader fit run too.

One part no fit move cleanly. fable-loop assume say the harness fit start parallel subagents and route dem go 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 dem easy to miss. 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 make 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 for every request wey you send, whether na one-line typo fix or refactor. 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; 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 suppose pass, or one script wey suppose exit 0. Vague task dey give vague comparison, because you go end up grading prose instead of results.

Run the control arm with --bare, wey skip auto-discovery of hooks, skills, plugins and CLAUDE.md. Na this flag make am control: the skills wey you install before no fit leak enter. Bare mode no dey use your subscription login, so set an API key from 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 flag added. E load the portable method as extra system prompt:

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. Na one flag dey different. Na only this way the comparison fit mean anything.

This design dey measure the method text. E no dey measure the skill packaging, because 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.

Count how many step dem take and wetin e cost

Both runs write one stream of JSON events. The last line na 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 dey change between Claude Code releases.

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

Cost for each run dey come from that line, and na the number you suppose compare:

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

To know the steps, count the 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 that command for both files. The shape of the difference tell you more than the totals. If method run read more files and edit fewer, e dey do wetin the method ask for, and na that trade-off you dey pay for. If method run make the same edits but cost forty percent more, you gain nothing for that task.

Two things to note 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 fit undercount. Trust the result line. Second, one run for each arm na just one example. Run each arm three or four times for the same task before you believe any gap, because even two runs of the same agent on the same task fit differ from each other. For the longer view of spending, the tools wey dey track Claude Code spending and how Claude Code dey count tokens explain why the cache lines dey 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.

The repo own eval, make we read am honestly

The README headline na "Fifteen eval rounds, more than 260 agent runs, blind LLM judges that verify by diffing and executing." This na more evidence pass almost any skill repo dey release, and eval/RESULTS.md dey write am round by round, with the failures kept inside. But once you check the individual cells behind the headline rows, e no as broad as the headline number make am look.

[
  {
    "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 rest on 4 runs. The other three get 2 runs each. The repo talk am by itself, for the standing limitations at the 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 more directly too: "This log exists so method edits are tested, not so anybody go mistake am for a benchmark."

Give credit for that. Author wey publish their own n, and name the problem say their judge dey built on the same model wey serve as baseline, dey more honest than the normal 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 go tell you about your codebase.

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

Wetin the packaging dey do like cargo cult

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

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

Four skills na more surface than the content need. fable-loop repeat 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. Na 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. E still be the kind gap wey tell you say the packaging move faster than anybody review am, and you suppose remember that when you decide how much of this to adopt at once.

Wetín 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 action wey you no fit reverse or wey affect outside system need the user's own words, written as an AUTH: line. If agent no fit find a 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 targeted check pass but the build still dey broken, verification fail. E no be pass.
• Outcome-first reporting, with anything wey you skip or leave unverified stated as caveat instead of quietly removing am.

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

FAQ

Fable method dey work with models wey no be Claude?

The method text dey work. Na ordered prompt wey no get model-specific code, and repo dey ship AGENTS.md as portable copy for Codex, Cursor, aider or raw system prompt. Two things no dey carry go. /fable-method and /fable-judge triggers na Claude Code slash commands, so for elsewhere you go invoke the method by describing am. And fable-loop assume say harness fit spawn 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, body go load only when 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 inside every request. The run itself too go cost more, because 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 and compare the total_cost_usd field.

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

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

Eval for the repo na benchmark wey I fit trust?

Treat am as change log for the method, as the author call 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 build on 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 by yourself.