# willison-fable-judgement-delegation-subagents-2026-07-03

## Veille

Short note from Simon Willison (weblog) relaying two tips heard during a *Fireside Chat* at AIE with Cat Wu and Thariq Shihipar (Claude Code team): **let the model (Fable, and to some extent Opus) exercise its own judgment rather than dictating rules to it** — illustrated with the decision of whether to write tests. Second tip, from Jesse Vincent: to **save precious Fable tokens** (ahead of an imminent price increase), ask Fable to **delegate small tasks to less powerful models**, letting it judge which one. Willison shows the exact prompt used (« *use your judgement to decide an appropriate lower power model and run that in a subagent* ») and the **memory file** that Claude Code wrote in response. Domain: prompt engineering, coding agents, token economics, multi-model orchestration.

## Titre Article

Fable's judgement

## Date

2026-07-03

## URL

https://simonwillison.net/2026/Jul/3/judgement/

## Keywords

Model judgment, delegation to subagents, model override, token economics, Fable, Opus, Sonnet, Haiku, Claude Code, agent memory, memory file, prompt engineering, Cat Wu, Thariq Shihipar, Jesse Vincent, not over-specifying, token price increase

## Authors

Simon Willison

## Ton

**Profile**: very short blog note (« note »), first person, practitioner-conversational register, low density but high use value. Medium-to-high technical level, aimed at everyday users of coding agents.

**Style**: anecdotal and immediate — Willison reports tips he received (« *the most interesting tips I got* »), applies them **live** (« *I prompted Claude Code just now* ») and delivers the raw result (the exact prompt, the generated memory file) with an honest empirical conclusion (« *So far it seems to be working well* »). Authority through **reproducible demonstration** rather than argumentation: he does not theorize, he shows the artifact. No metaphor; utilitarian tone, almost a public *lab notebook*. The economic pressure (« *the few days we have left before the prices go up* ») gives the tip a time-sensitive, perishable character. **Target audience**: developers using Claude Code / Fable, cost- and efficiency-conscious.

## Pense-betes

- **Core idea: judgment beats prescription.** Tip from Cat Wu & Thariq Shihipar (Claude Code team, *Fireside Chat* at AIE): let **Fable** (and to some extent **Opus**) decide *how* to work, rather than dictating rigid rules. The model has enough discernment to make its own calls.
- **Canonical example — tests.** Instead of the explicit rule « *only use automated testing for larger features, don't update and run tests for small copy or design changes* », it is better to simply tell Fable **to use its own judgment** to decide when to write tests. The hard-coded rule is more fragile than contextual judgment.
- **Second tip (Jesse Vincent) — saving Fable tokens through delegation.** Time-sensitive context: **imminent price increase** (« *the few days we have left before the prices go up* »). Countermeasure: ask Fable to **hand off small tasks to less powerful models**, letting it judge which one — instead of processing everything with the premium model.
- **The exact prompt used**: « *For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent* ». The pattern combines both tips: delegated judgment **+** multi-model orchestration via **subagents** with *model override*.
- **The generated artifact — a memory file.** Claude Code wrote on its own `~/.claude/projects/<project>/memory/delegate-coding-to-subagents.md` (frontmatter `type: feedback`, `node_type: memory`), which **encodes the rule and its mode of application**: *sonnet* for substantial implementation, *haiku* for trivial/mechanical edits; **judgment, review, and synthesis stay with the main model** (design, audit, data synthesis = never delegated).
- **Underlying doctrine of delegation**: « *implementation work rarely needs the top-tier model; judgment, review, and synthesis stay with the main loop* ». The main loop keeps its head; the hands (writing code) drop down a model tier.
- **Empirical result (not quantified, honest)**: « *I'm getting a ton of work done and my Fable allowance is shrinking less quickly than before.* » → productivity maintained, Fable consumption slowed.
- **Link to this repository**: the mechanism described (memory file `type: feedback` under `~/.claude/projects/.../memory/`) is **exactly** the persistent memory system used here. Willison's note is a public demonstration of the same pattern « *delegate coding to subagents with model override* » — directly transposable to our workflow.
- **Related**: same family as the *Compounding Knowledge Lifecycle* fiche (agent memory that captures *feedback* to replay it) and as the *loop engineering* / subagent orchestration tips.

## RésuméDe400mots

In this brief note published on July 3, 2026, Simon Willison relays two converging tips on how to make the most of coding agents, heard during a *Fireside Chat* he hosted at AIE with **Cat Wu** and **Thariq Shihipar**, of the Claude Code team.

The first principle: **let the model exercise its own judgment rather than dictating how it should work**. This applies to **Fable** and, to some extent, to **Opus**. The example given concerns tests. One *can* write an explicit rule — « *only use automated testing for larger features, don't update and run tests for small copy or design changes* » — but it is **preferable to simply ask Fable to use its judgment** to decide when to write tests. The model's contextual discernment proves more robust than the hard-coded rule.

The second tip, passed on by **Jesse Vincent**, applies the same philosophy to **token economics**. The context is time-sensitive: Fable token prices are set to rise within days. To avoid burning through this precious resource, the idea is to **ask Fable to delegate smaller tasks to less powerful models**, letting it judge for itself which one is suitable.

Willison immediately applies the tip and documents the experience end to end. He provides the **exact prompt** sent to Claude Code: « *For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent* ». In response, Claude Code **spontaneously wrote a memory file** (`~/.claude/projects/<project>/memory/delegate-coding-to-subagents.md`, `type: feedback`). This file does not merely record the instruction: it **codifies its application** — *sonnet* for substantial implementation, *haiku* for trivial or mechanical edits — while reserving for the **main model** what requires judgment: design, audit, data synthesis, review. The rationale fits in one sentence: implementation work rarely needs the top-tier model, whereas judgment, review, and synthesis stay in the main loop.

The verdict is empirical and measured: « *So far it seems to be working well. I'm getting a ton of work done and my Fable allowance is shrinking less quickly than before.* » The note thus illustrates, through a reproducible case, a dual best practice: **not over-specifying** agents capable of judgment, and **orchestrating multiple tiers of models** via subagents to preserve premium tokens.

## GrapheDeConnaissance

- Cat Wu —recommande→ laisser Fable et Opus exercer leur propre jugement plutôt que dicter des règles (AFFIRMATION, 0.95)
- Thariq Shihipar —travaille_chez→ équipe Claude Code (ORGANISATION, 0.95)
- Cat Wu —travaille_chez→ équipe Claude Code (ORGANISATION, 0.95)
- Jesse Vincent —recommande→ déléguer les petites tâches à des modèles moins puissants pour économiser les tokens Fable (AFFIRMATION, 0.93)
- Fable —permet→ décision contextuelle sur l'écriture des tests (jugement du modèle) (CONCEPT, 0.9)
- Simon Willison —utilise→ délégation des tâches de code à des subagents à modèle moins puissant (METHODOLOGIE, 0.95)
- Délégation à des subagents —utilise→ model override (Sonnet, Haiku) (TECHNOLOGIE, 0.92)
- Délégation à des subagents —réduit→ Fable (CONCEPT, 0.9)
- Claude Code —a_créé→ Fichier mémoire (DOCUMENT, 0.95)
- Fichier mémoire —affirme_que→ "implementation work rarely needs the top-tier model; judgment, review, and synthesis stay with the main loop" (CITATION, 0.92)
- Sonnet —s_applique_à→ implémentation substantielle de code (CONCEPT, 0.9)
- Haiku —s_applique_à→ éditions triviales ou mécaniques (CONCEPT, 0.9)
- Jugement du modèle —s_oppose_à→ règles explicites codées en dur (CONCEPT, 0.88)
- Simon Willison —affirme_que→ "I'm getting a ton of work done and my Fable allowance is shrinking less quickly than before" (CITATION, 0.9)

---
Canonical: https://www.thekb.eu/en/fiches/willison-fable-judgement-delegation-subagents-2026-07-03/