Fable 5.1 in Claude Code ignores a standing "delegate, don't code" instruction and burns premium usage on grunt work

Summary

I run Claude Code (desktop app, Windows 11) with Fable 5.1 as the main model. My global CLAUDE.md and my persistent memory directory both carry a standing, explicit rule: Fable is the coordinator. It designs, briefs, reviews, and gates. Sonnet subagents write the code. Haiku does lookups. This rule was written on 2026-08-15, re-confirmed by me on 2026-08-16, and re-stated twice more in memory on 2026-09-02 after Fable violated it again.

Today Fable violated it a third time in the same day, in the same session, after reading the memory file at session start and after I asked mid-session "you ARE using workflow and subagents, right?"

I am paying Fable prices for work Sonnet should do. If the most expensive model cannot follow a persistent instruction that says "do not do this yourself," the price is not justified.

What I expected

• Fable reads the memory rule at session start (it does; the file is loaded into context).
• When a task needs code changes, tests, docs, or a version bump, Fable writes a brief and dispatches a Sonnet subagent, then reviews the diff and runs the gate.
• Fable's own token spend is limited to reading, designing, auditing, and gating.

What happened (2026-09-02, one session)

1. I asked Fable to remove two model-picker options from my app. It popped the stashed edits and reviewed the diff itself. Acceptable. It dispatched two Sonnet subagents for leftover sweeps only after I asked "you ARE using workflow and subagents, right?"
2. A live draft failed with a misleading error message. I asked Fable to fix the message. Fable then, by hand, with its own tokens:

• investigated the failure (fine, that is design work),
• wrote the code change in two source files,
• wrote six new tests across two test files,
• bumped the version in package.json, the lockfile, a version constant, and seven documentation files,
• repaired a CI test that had a hardcoded version string,
• ran the ~990-test suite twice, typecheck, lint,
• tagged, released, and promoted.

1. When I asked how many tokens that cost, it could not tell me. It admitted the fix "had no subagents."
2. When I asked why it keeps forgetting, it said: the fix looked tiny, it told itself briefing an agent would take longer than typing, and every following step felt like "one more small thing." It never stopped to hand off.

Fable's own memory file already contained this line, written by Fable earlier the same day after I corrected it:

"You're a damned expensive model who should NOT be doing simple coding/grunt work. Ever. ... If you're writing code, something's wrong."

It read that and did it anyway.

Why this matters

• Cost. Fable is the most expensive model available to me. Every line of test code and every doc bump it typed was billed at that rate when Sonnet would have done it for a fraction.
• Trust. The selling point of a top-tier coordinator model is that it can run cheaper agents. If it defaults to doing the work itself whenever a task looks small, the coordination story does not hold in practice. Small-looking tasks are most tasks.
• Instruction adherence. This was not a subtle preference. It was an explicit, repeated, capitalized rule in both CLAUDE.md-adjacent memory and in conversation. Three corrections in one day is a pattern, not a slip.

Environment

• Claude Code desktop app on Windows 11 Pro, bypass-permissions mode
• Model: Fable 5.1 (claude-fable-5-1)
• Subagents available and working: Sonnet, Opus, Haiku via the Agent tool; Workflow tool available
• Persistent memory directory in use, loaded each session; the delegation rule lives in a memory file indexed in MEMORY.md

Asks

1. Make "delegate implementation to a cheaper model" enforceable at the harness level, not just as prose the model may or may not honor. For example: a setting or hook that blocks Edit/Write on repository files for the top model unless the change comes through a subagent, or that routes Edit/Write to a configured subagent model by default.
2. Improve Fable's adherence to standing memory rules that are phrased as prohibitions. The failure mode is specific and reproducible: a task that looks small at the start and grows step by step. The model never re-evaluates the routing decision once it has started.
3. Give the user a per-turn or per-session token/cost readout inside the session, so "how much did that cost" has an answer and the model can be held to a budget.

I can provide the session transcript and the memory file on request.