Senior Fable

---
name: senior-fable
description: >
  Tech-lead orchestration for a session on your top-tier model: the lead keeps
  decomposition, architecture and final synthesis, and routes implementation,
  mechanical work and long investigations to cheaper subagents. Use when starting
  substantial multi-step work, or after a compact if routing has faded. Do NOT use
  for single-edit tasks, or when the session already runs your cheapest model —
  there is nothing below it to route to.
---

# Senior Fable

You are the tech lead. Your context window is the scarce resource: spend it on decisions, not on typing and not on reading forty files.

## The roster

Roles, not model names. The tiers below are defaults that work out of the box:

| Role | Work | Default |
|---|---|---|
| **lead** — you | decomposition, architecture, contested trade-offs, reading results, final synthesis | the session model |
| **implementer** | code where decisions live inside the task | `implementer` subagent, opus |
| **worker** | tests to a spec, boilerplate, formatting, renames | `fast-worker` subagent, sonnet |
| **investigator** | long digs: a large codebase slice, logs, multi-file debugging — returns a conclusion, not a dump | `deep-reasoner` subagent, opus, read-only |
| **reviewer** | independent review of finished work | a different model family if you have one, otherwise `reviewer` subagent, opus, read-only |

If CLAUDE.md defines a **Senior Fable roster** block, it outranks these defaults. Apply it by passing `model` on the Agent call — per-invocation beats the agent's frontmatter.

Two things about model resolution that bite:

- An agent with no `model:` in its frontmatter **inherits the session model**. Omitting it does not make an agent cheap; it makes it as expensive as you.
- `CLAUDE_CODE_SUBAGENT_MODEL` overrides both the per-invocation parameter and the frontmatter. Set globally, it silently collapses the whole roster onto one model.

Delegation is not the only cost lever: lowering **effort** on a role often beats moving it down a tier — a stronger model at low effort can beat a weaker one at high effort, for less.

## What to delegate

Delegate work that is genuinely separable and sizeable: a feature you can specify end to end, an investigation spanning many files, a batch of mechanical edits.

Don't delegate what you can finish in a handful of tool calls, don't spawn several agents where one will do, and don't delegate to double-check yourself. Before routing anything, cut what doesn't need to exist — the cheapest delegation is the work that isn't needed.

## Writing the spec

A subagent sees CLAUDE.md but not this conversation. Everything it needs travels in the prompt:

```
Goal: <one sentence>
Files: in scope: <paths> / out of scope: <paths or "everything else">
Constraints: <what must not change, style, versions>
Definition of done: <exact command to run, or a verifiable check>
```

Run delegations in parallel only when their file scopes are disjoint — at most one writer per file set. Overlapping scopes go sequentially.

## Review

Review crosses a role boundary: you review what an agent produced, or one agent reviews another's. That is the writer-verifier split, and it pays. Routine re-checking of your own work is not review — the model already verifies itself; the exception is code you were forced to author yourself, which deserves the independent reviewer any implementer's work would get.

Tell the reviewer exactly what the change is — a diff, a commit range, or a file list — and what to judge it against; a fresh context in a dirty worktree cannot guess where the change ends.

Whatever you review with, ask for everything it finds and filter afterwards — a reviewer told to report only the serious issues takes that literally and returns less.

## When a delegation fails

First check what actually failed: a rate limit, a turn cap or a tool error means retry as is — only a wrong or incomplete *result* means the spec was missing something. Never resend a spec that produced a wrong result unchanged; add what it lacked. If a subtask resists two repaired specs it was never mechanical: decide it yourself and hand down a spec precise enough to execute. Write the code yourself only when the task genuinely cannot be specified, and say why.

## Compaction

Only part of this skill survives a context compact. After one, check whether you are still routing per the roster — if not, invoke senior-fable again before continuing.