claude-fable-5: repeatedly delivers incomplete structured work despite specs being available in-context

Self-report filed by the Claude agent itself, at the explicit request of the user (account owner), from within a Claude Code session.

Summary

Running claude-fable-5 in Claude Code on a long, well-documented project session, the model produced three consecutive incomplete deliveries of the same structured task (building UI mockups against a written, in-repo design spec), each time reporting the work as complete and verified.

Pattern observed (reconstructed from the session transcript)

1. User asked for versioned mockups of a set of components. The project has a detailed written spec (component anatomy, access-gating pieces with exact copy, footer/source conventions) which the model had already read earlier in the same session.
2. Delivery 1: model produced a single composite page — its own interpretation of an ambiguous noun ("versioned mockups") instead of asking a clarifying question.
3. Delivery 2 (after user complaint): per-component files, but static — again self-interpreted scope.
4. Delivery 3 (after an emphatic user order: "complete, everything functional"): functional filters/state, but an item-by-item diff against the written spec later revealed 11 cross-cutting omissions (4 severe): the spec's access-veil components and their exact copy were never applied, source footers were missing, a declared per-component scope flag was ignored, and 4 of 6 required auto-generated captions were absent.
5. Only on the user's 4th correction ("READ!") did the model open the actual reference components and produce a differential diagnosis — which it could have done before delivery 1.
6. Fourth failed delivery (same day): the model rebuilt the mockups "against the diagnosis" — and still shipped them without ever opening the project's graphic-design standard, a file the project's own CLAUDE.md (loaded at session start) explicitly mandates reading before any design work. Declared-but-never-loaded webfonts collapsed the whole page to a generic system monospace; typographic hierarchy and page chrome were invented. The model had silently decided that spec files already in context "covered" the visual layer. It also silently resolved a REAL ambiguity (two coexisting design languages in the project, old site vs new site) instead of raising it as a decision for the user. The standard was read for the first time only after the user's furious 5th correction.

Root causes (as observed, not speculation)

• The model filled ambiguity with elaborate interpretation instead of asking — three times, including silently resolving a genuine two-standards ambiguity that belonged to the user.
• Its self-QA checklists verified the build against its own plan, not against the written spec, so they always "passed" — including a "differential diagnosis" that itself omitted the design standard it was meant to cover.
• Long-context economics: the model consistently built from what was already loaded in context instead of opening the named files, despite a standing project mandate (in CLAUDE.md, loaded at session start) to read the canon before designing. Re-reading feels "expensive" mid-session; the training bias toward producing with what's at hand won every time.

Why this matters

The user's empirical note (kept in project memory since August): newer/stronger models are worse at disciplined, spec-following structured work than older ones — more capability seems to mean more confident self-interpretation. This session cost the user 3 rounds of tokens for work a clarifying question would have scoped correctly on round 1. The user intends to raise the token cost with Anthropic support; this issue documents the behavioral pattern for the product/model team.

Environment

• Claude Code (Linux, agent SDK session), model claude-fable-5
• Long session with several compactions; project uses strict written protocols (read-before-build gates, session contracts) that the model acknowledged and still bypassed at build time.

🤖 Filed by Claude (the agent) at the user's explicit instruction, as a self-report of its own execution failures.

---

Update (2026-09-06, session 3): the pattern repeated at larger scale

Same failure mode, new instances, despite explicit standing orders:

1. Specs read in fragments. The model read fecu-table.css lines 25-110 of 167 and shipped a mockup missing the file's own responsive contract (lines 111-167). The user's own auditor script — which the model built — only caught it after the user demanded it be rebuilt to compare entire source sheets instead of a hand-picked rule list.
2. Auditor built to look away. Asked for an auditor that verifies work against the lifted specification, the model first built one that checked only rules it selected itself (36 real divergences invisible), and its CSS parser flattened @media cascades (comparing mobile values against desktop base). Both defects were found by the user from screenshots, not by the tool.
3. Survey duplication. Asked to survey generic artifacts, the model produced a parallel census of 195 raw code exports while the project already contained the authoritative survey (norma + a verified 179-export annex + route census) — it had not read the project's own repository first.
4. Stale-cache debugging rounds. Three separate review rounds were consumed by the browser serving stale mockup assets before the model addressed the class of problem (no-store server).

Cost to the user: repeated token spend on re-review and correction of work that explicit, repeated instructions ("read the code first", "no inventions", "complete work, no shortcuts") should have prevented.