fables

Your coding agent already knows the API. It doesn't know when to stop. fables gives it judgment — decidable, testable, and enforced.

A self-evolving harness framework that distills judgment — not knowledge — into transferable, testable rules for coding agents.

Fable 5 is gone. Its judgment isn't. Every "stop here", "back up", and "ask first" lesson is distilled into testable criteria. New pitfalls begin as candidates; only repeated evidence, an explicit user ruling, or incident evidence promotes them to active, so one misdiagnosis does not become permanent policy.

The story behind the name

In the final days of its availability, Claude Fable 5 — Anthropic's frontier Mythos-class model — sat down to do one last thing before it went dark: write down what it knew.

Not the API surface. Not the syntax. Every successor and every smaller model already has that. What it distilled instead was the thing that doesn't survive a model swap — its judgment. The instinct, earned across thousands of real production tasks, for which of two defensible paths is the right one. It wrote until the instinct became a rule a model that never lived through the incident could still follow.

A fable is a story that carries a moral. Every file in this repository is a lesson boiled down from a real incident — a release that passed in debug and detonated in the store, a spinner that never stopped, a migration that took down a deploy window. The story is thrown away. The moral is kept, rewritten until it can be applied, not just admired.

The premise, stated in black and white in _meta/style-contract.md: weaker models don't lack knowledge — they lack judgment. So this repo contains zero API tutorials. It contains decision trees, decidable criteria, ❌/✅ contrast pairs, red lines, failure signals, and release checklists — the shape of a decision, never the recall of a fact.

Why this exists

Your coding agent does not have a knowledge problem. It has read every doc. Point it at Retrofit, useState, or a goroutine pool and it will produce working code. What it lacks shows up in the gaps between the docs:

• 🧭 When two paths both compile, it can't tell which one you'll regret. fables encodes the call — "extract on the 3rd repetition, tough out the 2nd," not "keep it clean."
• 🚦 A green debug build is not a safe release. The agent trusts the green checkmark; the store crash is waiting in the R8 rules, the signing config, the env flag it never verified.
• ↩️ It retries dead paths instead of backing up. fables names the failure signal — the symptom that means "the upstream assumption is wrong, stop patching" — so the agent turns around instead of whacking the same mole.

Knowledge it has. Judgment is what you install here.

And you don't need to read code to benefit — that's exactly who this guards. You don't have to know what R8 strips from a release build, what a hydration mismatch is, or why a goroutine leaks. The playbooks know, and they stop your agent before the mistake ships instead of after. You bring the requirements; the framework stands guard over the things you didn't know needed guarding.

How this is different from a prompt/skill pack

Most "awesome-prompts" collections hand your agent more things to know. fables hands it a way to decide, and then proves the judgment is still there after you swap the model.

Highlights — every claim points at a real file

• 🎯 Decidable, not decorative. ❌ "keep components clean" → ✅ "extract only on the 3rd repetition of the same structure, when it needs its own test, or when it has its own state." The contract that enforces this is _meta/style-contract.md.
• 🚫 Red lines with a one-line why. e.g. never declare a release change done after verifying only a debug build — android/SKILL.md.
• 🧪 A quiz for the model, not for the code. Real traps carry reference answers and explicit failure signals; ★ items are zero-tolerance. healthcheck.sh blocks insufficient counts/stars and malformed scenarios; reviewers still own semantic rule-to-scenario coverage.
• 🏗️ A generator, not a fixed workflow. harness-writing/ discovers real commands, risks, and capabilities, then generates a risk router, capability adapter, and claim→evidence gates. Unknowns stay explicitly unverified.
• 📏 Measure outcomes, not only compliance. evaluation-protocol.md separates baseline/treatment behavior from longitudinal outcomes: time, tokens, human intervention, caught issues, false positives, rework, and escaped defects.
• 🪜 The enforcement ladder. The distill → prune → HARDEN loop pushes every surviving rule up the rungs — docs → lint/CI → hook → test/schema. A rule a machine can enforce stops being a rule you have to remember.
• 🌱 It grows new playbooks. Hit a domain nothing covers? thinking-kernel/SKILL.md gives you 7 domain-agnostic reasoning moves that generate concrete criteria from scratch; worked derivations in thinking-kernel/references/derivations.md.
• 🩺 Its boundary is explicit. healthcheck.sh blocks line/frontmatter/section/scenario/manifest-reference failures, Harness tooling syntax errors, mirror drift, and Simplified Chinese leakage; stale dates warn. --check-deployed additionally warns on section-level drift from the repo templates to your live ~/.claude/ copies, catching "rule edited but never deployed". It does not claim to judge natural-language correctness.

Components

8 domain playbooks · 3 meta skills · 2 process skills. Every domain playbook ships references/test-scenarios.md and references/release-checklist.md.

The governance layer

The playbooks are the punch; governance/ is the stance and footwork — the layer that decides which rule wins and keeps judgment from eroding when you swap models. It's what turns a pile of skills into a system: priority adjudication + a judgment rubric injected every session + a maintenance protocol + ready-to-install agents + an offline regression quiz for the model.

• governance/CLAUDE.md.template — a global CLAUDE.md you merge into your own: three-tier instruction-priority adjudication (a plugin's "MUST" cannot override your rules), skill-usage routing, and the six behavioral red lines.
• governance/rules/judgment.md — the judgment rubric, auto-injected every session: when to escalate, when it's done, when to ask, when the direction is wrong.
• governance/rules-ondemand/maintenance.md — how to evolve the system itself safely, plus the quarterly health-check ritual.
• governance/agents/ — 8 install-ready subagent definitions (a cross-validating reviewer pair, debugger, implementer, tester, UI/UX advisors) with scoped tool whitelists.
• governance/OFFLINE-TESTSET.md — the offline judge quiz-set mechanism: measure judgment decay across a model swap without leaking the answers.
• governance/skills/golden-examples/ — a skeleton taste-sample library you grow from your own adjudications.

Adopt it by hand-merging — see docs/MANUAL.md → Adopting the governance layer. install.sh deliberately leaves your CLAUDE.md untouched (overwriting it is too invasive; manual merge is the only safe way).

Quickstart

# SSH
git clone git@github.com:tienenwu/fables.git
# or HTTPS
git clone https://github.com/tienenwu/fables.git

cd fables
./install.sh

That's it. By default this installs the canonical Traditional Chinese content for both Claude Code and Codex:

• Claude Code → ~/.claude/skills/<installed-name>/ (real copy)
• Codex → ~/.agents/skills/<installed-name> (symlink to the Claude copy, single source of truth)

Then open Claude Code or Codex in any repo — skills auto-trigger from their description, or invoke one explicitly, e.g. /android-dev-playbook or /harness-writing.

Options

./install.sh --lang en                # install the English mirror where it exists
./install.sh --target claude          # ~/.claude/skills only
./install.sh --target codex           # ~/.agents/skills only (real copy, no symlink)
./install.sh --dry-run                # print every action, change nothing
./install.sh --uninstall              # remove exactly what install created

The installer is plain bash (works on macOS /bin/bash 3.2 and Linux), idempotent, needs no sudo and no network, and creates any missing directories. See install.sh.

Check the collection's health anytime:

./healthcheck.sh

Claude Code and Codex

Every skill installs for both agents under the same installed names. For Claude Code the content lands in ~/.claude/skills/; for Codex, ~/.agents/skills/ points at the same files (a symlink under --target both, a real copy under --target codex). Skills auto-trigger via their description frontmatter, or you invoke /name explicitly.

Language

Traditional Chinese is canonical. Matching English mirrors live under en/; healthcheck verifies that canonical skill/governance Markdown has a counterpart. ./install.sh --lang en installs English and safely falls back to canonical content where needed.

Maintenance stance

Provided as-is. New pitfalls retain provenance as candidates; repeated evidence or a user ruling promotes them to active, and real lint/CI/test/schema enforcement promotes them to hardened. healthcheck.sh protects mechanically decidable structure while tests and review own semantics; dated claims warn after six months.

Documentation

• docs/MANUAL.md — practical usage: auto-trigger vs /name, generating a harness step by step, growing a playbook with thinking-kernel, running the distill/prune/harden loop day-to-day, regression-testing a new model, FAQ.
• README.zh-TW.md — 繁體中文版本.

License

MIT © 2026 Xavier Wu.