Fable 5 users report $149.25 sqlite-utils work and X API hallucinations

• Simon Willison's Weblog writeup says Claude Fable helped get sqlite-utils to 4.0rc2 by finding five release blockers, including a delete_where() transaction bug, for about $149.25.
• mattpocockuk's 10-minute test reported two factual hallucinations, and his follow-up named X API OAuth requirements and X API pricing as the misses.
• Steve_Yegge's outage report, badlogicgames' finance report, theo's iOS report, and GergelyOrosz's accounting run all found domains where Fable still needed heavy steering or manual follow-through.
• zeeg's verification thread framed the new bottleneck as automated verification cost, while dexhorthy's benchmark note pointed to a concrete test-quality rule: new tests must fail on pre-patch code.
• petergostev's effort table measured a single prompt at 12 minutes on low effort and nearly 2 hours on max, while bridgemindai's subscription screenshot showed users buying extra Claude Max plans to keep using Fable.

The sqlite-utils writeup includes the exact data-loss reproduction. The effort table puts one prompt at 73.2K tokens on low and 367.1K tokens on max. A Reddit cache analysis claims Claude Code subagents are overpaying 14% on prompt cache. The reMarkable demo is still the weirdest user-facing artifact: handwriting fades, model handwriting appears.

According to Simon Willison's Weblog writeup, the final sqlite-utils 4.0 review started from Claude Code for web on an iPhone with a prompt asking Fable to spot last-minute breaking changes before a stable major release.

Fable found five items it categorized as release blockers. The worst one was Table.delete_where(), which ran a DELETE through a bare self.db.execute() without the atomic() wrapper used by Table.delete().

The repro in the writeup left conn.in_transaction=True, pushed later atomic() calls into the savepoint branch, and lost the delete, a later insert, and a new table after close and reopen.

The 4.0rc2 release note points back to the same writeup. Willison's later note called the review humbling and put the estimated unsubsidized cost at $149.25.

Christmas come early for coding-agent nerds: a public Python package shipped with both a serious model-found data-loss bug and a line-item model bill.

mattpocockuk's first report said Fable produced two factuality hallucinations in 10 minutes. His follow-up listed the two misses: misunderstanding OAuth requirements for X API endpoints, and not knowing the X API had become cheaper.

mattpocockuk's clarification said Fable remains prone to the same failure modes as lesser models. A later reply labeled the issue a factuality hallucination rather than a faithfulness hallucination, and another reply said the model should have used a tool proactively instead of guessing.

The practical failure mode is not exotic. It is an uncited, tool-checkable claim about a live API.

The negative reports clustered around domains with hidden constraints, live systems, or exact external facts.

• Steve_Yegge's report said Fable ran in circles across sessions on a production outage, then turned the failure into a new eval for future models.
• badlogicgames' finance report said Fable “sucks at finance,” and his follow-up described using deterministic code for most tax automation instead.
• theo's iOS report said Fable was strong at infra, databases, and web, but “easily confused” about mobile apps.
• GergelyOrosz's accounting run found browser automation clunky, slower than doing the work manually, and halfway through quota before the accounting was done.
• GergelyOrosz's follow-up said the business task still had manual work remaining, while his tooling note separated the promise of autonomous browser work from the current slowness of the model plus integration.
• eliebakouch's xhigh test said Fable missed current AI-industry facts and that Opus did better on that prompt.

These are boring failures in the useful sense: OAuth, finance, iOS, accounting, outages, and current facts.

zeeg's thread argued that LLM-generated changes now demand large amounts of automated verification, and the follow-up said the gap between side projects and Sentry projects widened because Sentry has verification agents and supporting tools that personal projects do not.

The test debate got concrete fast:

• zeeg's test critique said models often substitute “does the code run at all” for meaningful tests.
• dexhorthy's Frontier code bench note said Cognition penalizes tests unless new tests fail on the pre-patch code.
• simonw's counterexample showed a Fable-created test he liked without intervention.
• simonw's testing note said he values conformance-style tests and will dictate their shape for parser work.
• zeeg's mocks example called out generated mocks for structured logging checks as wasted inference and worse software.
• simonw's mocks rule said he avoids agent-written mocks except around external HTTP endpoints.

mattpocockuk's review workflow described a three-stage loop: implementation, automated review in a separate session, then human review. zeeg's Warden example showed why mutation-style checks matter: a vacuous regression test passed until deleting the real guard made the test fail.

The dominant workaround is to spend Fable on judgment, not bulk code generation.

simonw's linked Fable's judgement post describes asking Fable to choose an appropriate lower-power model for coding tasks and run it in a subagent. simonw's reply said he did not trust Opus enough for that kind of decision yet, but was getting there with Fable.

The pattern showed up in several forms:

• MatthewBerman's routing plan used Fable for planning and GPT-5.5 for execution.
• dzhng's implement-with-codex skill wrapped the repeated prompt for using Codex as implementer, and his reply said the orchestrator creates worktrees for each subagent.
• daniel_mac8's plugin post packaged Fable as an advisor that minimizes its own token usage and delegates implementation to GPT-5.5 through Codex CLI.
• kevinkern's Planr model-routing screenshot put backend, frontend, and review work into a shared task map with model assignment attached.
• pvncher's subagent note called subagents a context-management tool that increases the scope of what one prompt can accomplish.

daniel_mac8's earlier post stated the compact version: Sonnet or Opus writes the code, Fable advises.

Fable's capability reports almost always came with a usage story attached.

petergostev's effort table measured the same prompt across effort levels:

• Low: 73.2K tokens, 27 tool calls, 12m 0s, 711 lines of code.
• Medium: 190.3K tokens, 58 tool calls, 44m 0s, 1,702 lines of code.
• High: 296.3K tokens, 88 tool calls, 1h 15m 42s, 1,660 lines of code.
• XHigh: 261.7K tokens, 165 tool calls, 1h 35m 30s, 2,291 lines of code.
• Max: 367.1K tokens, 122 tool calls, 1h 50m 40s, 2,425 lines of code.

yacineMTB's single-prompt report put one prompt above $130, and his daily-cost estimate said using Fable like Codex 5.5 would cost about $300 per day. zeeg's first-session report put one session at $400 and described a 1 to 2 hour human-in-the-loop task turning into 6-plus hours of inspection.

bridgemindai's subscription post said the weekly Fable limit died in about a day of real building and showed a third $200 Claude Max subscription. a Reddit quota report said one day of Fable use reached 96% of the user's weekly Fable quota.

The clearest wins were visual, interactive, or product-shaped.

• cedric_chee's game demo showed Fable building a 1990s Diablo-style game with dungeon levels, quests, and maps.
• petergostev's 60-demo video covered hard 3D prompts, mini-games, and world-building tests.
• mattshumer_'s Hogwarts demo showed a cinematic fly-through generated by Claude Fable 5.
• MaximeRivest's reMarkable demo turned a developer-mode reMarkable tablet into a handwriting interface where prompts fade and model responses appear in ink.
• ai_for_success's Obsidian graph demo connected a Notion-to-Obsidian brain graph to Iris and Hermes with semantic search powered by Gemini Embedding 2.
• bridgemindai's redesign demo claimed a website redesign, a lightning animation on a CTA, an interactive BridgeSpace demo, and three marketing videos.
• emollick's AAA game experiment showed Fable escalating a game with graphics, boss fights, mechanics, custom sounds, and soundtrack additions until WebGL limits appeared.

The demo reel explains the hype better than the benchmark charts: Fable is unusually good at turning vague product taste into working artifacts, then spending a terrifying number of tokens polishing them.

A Reddit analysis of Claude Code transcripts claimed Claude Code is overpaying about 14% on subagent prompt cache and about 8% of total spend in a heavy-subagent workflow.

The post said the analysis covered about 95 sessions, 1,800 subagents, and 6.8B input tokens. The author traced the excess cost to two structural issues: subagents resend about 30K tokens of static context on startup, and a parent's 5-minute cache can expire while it waits on a child.

The proposed fixes were narrow:

• Put a 1-hour TTL on the write right before a child dispatch, modeled at about 6% savings.
• Put a 1-hour TTL on identical per-type static prefixes and move dynamic content after them, modeled at 7.6% savings.
• Keep the default 5-minute cache on the churning conversation tail.

The post points to the linked GitHub issue with the billing math and local transcript parser. Its nastiest detail: the obvious fix, giving subagents the 1-hour cache everywhere, was modeled as 8.6% worse.