fablize: enforcing completion and verification as procedure in Claude Code

The problem fablize sets out to fix

A capable coding model can still stop short: claim a task is done without running what it built, promise an action instead of taking it, or fix a bug without tracing why it happened. fablize is a Claude Code plugin that turns the habits of thorough work into enforced procedure so the model reaches its own ceiling rather than stopping below it. The framing comes from a controlled comparison the author ran between Fable and Opus, and the plugin's thesis is precise: it does not try to raise a model's capability, it makes the model actually carry out the disciplines it is capable of. The audience is Claude Code users who have watched a strong model declare success too early and want a deterministic backstop, not a prompt that politely asks for rigor.

What the author found transfers, and what does not

fablize is unusually disciplined about scope, and that is its most interesting design decision. The README reports a self-run comparison, an A/B set of 19 runs plus real working sessions, and draws a line between two kinds of trait. Procedures transfer: running and observing an artifact before calling it done, decomposing multi-part work and refusing a groundless completion, and investigating a bug by reproduction and causal chain. Capability does not transfer: finding out-of-spec defects, open-ended creative depth, and self-started propagation could not be injected, and an experiment to inject them was refuted. So the plugin ships only the procedures whose effect the author verified and deliberately leaves out ideas like style mimicry or broad reasoning injection until a controlled test confirms them. When you hit a capability limit, it tells you to escalate rather than pretending.

Router, gates and the early-stop hook

The mechanism is a set of hooks and a router rather than a block of prompt text. A per-task router, implemented as a UserPromptSubmit hook, injects only the discipline that matches the task: two or more stories trigger decomposition and a verification gate, a debugging task triggers the investigation protocol, and a render artifact triggers verification grounding. The multi-story gate is backed by a goals.py that decomposes work and refuses a completion without proof. Render or executable artifacts, HTML, SVG, games, charts, are meant to be run and observed before the work closes. A deterministic early-stop hook catches the pattern of promising an action without doing it. The design keeps the injection targeted, so trivial turns are not burdened with machinery they do not need, which the changelog frames as reducing gate noise.

Installing the plugin

fablize installs through Claude Code's plugin system. You add the marketplace entry and install the plugin:

/plugin marketplace add fivetaku/fablize
/plugin install fablize

The per-task router registers automatically as a UserPromptSubmit hook. For always-on operation, where the rules stay resident in context rather than being injected per task, you run its setup script once and choose a local or global install:

bash ${CLAUDE_PLUGIN_ROOT}/setup/setup.sh

After that you trigger it with /fablize or phrases such as see it through, or let it run automatically when installed always-on. Uninstalling is the matching uninstall.sh. The README notes the setup asks once whether you want to star the repository and never does so without an explicit yes, which is a small but honest detail about a script that runs in your shell.

Honest limits the project states itself

fablize is candid about what it cannot do, and taking that seriously is the point of a fair review. It cannot raise model capability: open-ended creative quality and self-driven discovery are out of reach, and the project says plainly that reaching for them is a model-choice decision, not a harness one. The effect numbers come from a small, single-family self-measurement on Claude models, so the README asserts the direction but not the decimals, and you should read the improvement claims that way. The early-stop hook can misfire on a declarative offer such as saying you will write a report if asked, and the workaround is to phrase offers as questions. These are the kinds of limits a tool usually hides, and stating them is a reason to trust the parts it does claim.

fablize versus a CLAUDE.md full of rules

The obvious alternative is to write the same disciplines into a CLAUDE.md or a system prompt and trust the model to follow them. That costs nothing to set up, but it is advisory: the model can still skip running an artifact or declare done without proof, because nothing enforces the rule. fablize's difference is enforcement through deterministic hooks and a router, so the early-stop pattern is caught mechanically and completion is gated on evidence rather than on the model's goodwill. The trade is added machinery and a plugin to install against a prompt file you already control. If your model reliably self-disciplines, a prompt may be enough; if you have seen it stop early on real work, fablize is built to make that failure mode harder, and it is honest that it does nothing for the capability gaps a prompt also cannot fix.

MIT license and release posture

fablize is MIT-licensed, so it is freely reusable, and its release posture matches its thesis. The 2.1.0 notes describe a measurement-first release: an observation gate that only blocks deep, changed, unverified turns to cut noise, and out-of-band shadow measurement infrastructure that sits outside the model context and does not change behavior, added specifically to measure effect rather than to assert it. The notes state there is no verified performance gain in that release, only the instrumentation to find one, which is a rare thing for a project to admit. The last push was on 2026-07-06. Adopt it for the enforced procedures, read its limits section before expecting more, and treat its numbers as directional self-measurement rather than a benchmark someone else reproduced.

Editorial conclusion

Adopt fablize if you run Claude Code with a strong model and want completion, evidence and verification enforced as procedure rather than requested in a prompt, and you accept it does nothing to raise the model's ceiling. Do not expect it to add out-of-spec defect discovery or creative depth, which the author verified do not transfer, and treat its effect numbers as directional self-measurement. Install with /plugin install fablize, and run setup/setup.sh once if you want the rules always resident rather than injected per task.

Frequently asked questions

Official sources

1. fivetaku/fablize on GitHub
2. Issues
3. License: MIT
4. README
5. Releases