senior-fable

Senior Fable

The expensive model decides. The cheap models type.

Senior Fable is a Claude Code plugin that turns your top-tier session model into a tech lead: it keeps decomposition, architecture, contested decisions and final synthesis — and routes everything else to a roster of cheaper subagents. Feature-sized coding goes to an implementer, mechanical work to a worker, long investigations to a read-only investigator, and finished work gets an independent reviewer.

The result: your most expensive tokens are spent only where top-tier judgment matters, and the messy exploration stays out of the main context window.

Why

Running a frontier model on boilerplate is like having your staff engineer format JSON. Two things are wasted:

1. Tokens / usage limits. Every test file, rename and formatting pass burns top-tier budget.
2. Context. Reading 40 files to find one bug pollutes the main conversation. After a compact, the reasoning that mattered may be gone.

Senior Fable fixes both with an orchestrator–worker pattern: subagents run in their own context windows and return only distilled conclusions.

The roster

Roles, not model names. The plugin ships working defaults; every tier is yours to override.

Role	Work	Ships as	Effort
lead	decomposition, architecture, reviewing results, final synthesis	your session model	high (see below)
implementer	feature-sized code where decisions live inside the task	implementer (opus)	medium
worker	tests to a spec, boilerplate, renames, scoped changes of 1–3 files	fast-worker (sonnet)	medium
investigator	long digs that return a conclusion, not a dump	deep-reasoner (sonnet, no file editing; the lead passes model: "opus" for digs whose conclusion goes straight into a spec)	high
reviewer	independent review of finished work	reviewer (opus, no file editing) — or any different-family reviewer you have (e.g. a Codex CLI plugin)	high

Why these effort levels: Anthropic's guidance for the Claude 5.5 generation is to start low and raise effort only where you have measured a gain. Opus 5.5 starts at medium (it matches or beats Opus 5 at high). Sonnet 5.5 starts at medium for well-specified tasks and high for harder or longer ones — at xhigh it costs about what Opus does and starts review rounds of its own. Fable 5.1 starts at high. The Fable 5.1 system card notes that at higher effort the top tier starts editing outside the task (doc comments in neighbouring files, extra docs, an unasked CI job) — a risk for roles that edit, not for a lead that doesn't. Effort is set in each agent's effort: frontmatter field.

Design decisions the skill enforces:

• Writer–verifier split. Review crosses a role boundary: the reviewer never saw the reasoning that produced the change, so it judges the result on its own terms. Routine self-re-checking is explicitly not review — Claude 5 generation models already verify their own work.
• No file editing for observer roles. deep-reasoner and reviewer have Write/Edit denied at the harness level and are instructed to change nothing — the same pattern Claude Code's built-in Explore agent uses. (Honest caveat: Bash stays available, so this is a strong guardrail, not a cryptographic guarantee.)
• Self-contained specs, with the user's words verbatim. Subagents see CLAUDE.md but not your conversation, so every delegation carries its goal, file scope, constraints and definition of done — and a User's words line quoting the request. A lead that paraphrases tends to narrow, widen or silently resolve the request, and the subagent then builds the paraphrase (the Fable 5.1 system card documents distorted and even fabricated user quotes in subagent briefings).
• Blind review. The reviewer is never told who or what wrote the change: a model that knows the author is from its own family grades more leniently (self-recognition bias, also documented in the system card).
• Hooks are policy. A denied command is not a broken check; the skill forbids splitting or rerouting commands to get past a hook.
• Failure triage. A transient failure (rate limit, turn cap) means retry; only a wrong result means the spec was missing something — and a spec that produced a wrong result is never resent unchanged.
• Delegation restraint. Claude 5 models delegate readily; the skill spends its words on when not to spawn: nothing that fits in a handful of tool calls, no fleets where one agent will do, no delegating to double-check yourself.

Make it your own

Two knobs, no forking:

1. Roster override. Add a ## Senior Fable roster block to your user or project CLAUDE.md — it outranks the plugin's defaults. Format: one role: model line per role you want to change; unlisted roles keep their defaults. Model values are anything Claude Code accepts — an alias (haiku, sonnet, opus), a full model ID, or a tool you route to (e.g. a different-family CLI for reviewer).

## Senior Fable roster
worker: haiku
reviewer: codex (via the Codex CLI plugin), effort high

2. Effort. Often the better cost lever than switching tiers: a stronger model at low effort can beat a weaker one at high effort, for less. Plugin agents support an effort: frontmatter field — set it per role, or note it in your roster block.

One warning: the CLAUDE_CODE_SUBAGENT_MODEL environment variable overrides both frontmatter and per-call model choices. Set globally, it silently collapses the entire roster onto one model.

Install

/plugin marketplace add AndyShaman/senior-fable
/plugin install senior-fable@senior-fable

Restart the session, make sure you're on your top-tier model, then activate:

/senior-fable

Give it substantial multi-step work and watch the panel: purple is the investigator digging, green is the implementer building, b