Simon Willison Shipped sqlite-utils 4.0 Mostly Written by Claude Fable — for $149.25

Simon Willison shipped sqlite-utils 4.0rc2 this week — and most of the code was written by Claude Fable, Anthropic’s frontier coding model, for a total API cost of $149.25. Over 37 prompts and 34 commits, Fable added 1,321 lines and deleted 190 across 30 files, catching a data-loss bug Willison had not encountered and fixing the library’s transaction model before a stable release.

🔍 THE BOTTOM LINE

The headline number is $149.25. The real story is the workflow: one frontier model writes the code, a rival frontier model reviews it, and both catch bugs the human missed. Willison — one of the most respected software engineers in the Python ecosystem — is now using AI coding agents as production infrastructure, not as a novelty. The cross-model review pattern is the part that matters.

The Bug That Almost Shipped

The most significant find was in Table.delete_where(). Fable’s review identified that the method ran its DELETE via a bare self.db.execute() with no atomic() wrapper — leaving the connection in an uncommitted transaction. Every subsequent atomic() call took the savepoint branch and never committed. The result: reopening the database showed the delete, the new row, and an entirely new table had all been lost.

“That’s a really bad bug! Very glad I didn’t ship that, although at least it would have been a bug I could fix in a 4.0.1 point release, not a design flaw that would force a 5.0.”

Willison reproduced the bug end-to-end from Fable’s report. This is not a model hallucinating a plausible-sounding issue — it is a model reading a diff, understanding Python’s sqlite3 transaction semantics, and identifying a state corruption path that a senior engineer had not hit in testing. That is the verification gap Fable 5’s Windows kernel write-up first surfaced, now showing up in a library that thousands of Python developers depend on.

The Cross-Model Review

The workflow did not stop at Fable. Willison then prompted Codex Desktop and GPT-5.5 xhigh — OpenAI’s frontier model — to review Fable’s changes. He had previously dismissed the idea as “somewhat absurd” and “weirdly superstitious.” It is not.

“The problem is it really does work — I’ve started habitually having Anthropic’s best model review OpenAI’s work and vice versa, because I’ve had that turn up interesting results often enough to be valuable.”

GPT-5.5 found two P1 issues Fable had missed:

db.query() now rejects non-row statements only after calling db.execute() — meaning db.query("update ...") raises ValueError but the update is already committed. A surprising side effect for a method documented as read-only.
INSERT ... RETURNING through db.query() only commits after the returned generator is fully exhausted. next(db.query(...)) or an un-iterated call leaves the transaction open — contradicting the changelog and documentation.

Willison pasted both findings into a fresh Fable session. Fable ran experiments to confirm both, then fixed them. The PR and full Claude Code transcript are published on GitHub.

What This Actually Costs

$149.25 is the number that will get quoted. It should not be the takeaway. The cost includes:

37 prompts across a multi-day session
34 commits, 30 files touched
Fable writing documentation, running experiments, and producing a release-blocker report
A second model (GPT-5.5) doing review

This is not “$149 to replace a developer.” It is $149 to accelerate a release that Willison — who has maintained sqlite-utils for years — would have shipped eventually, but slower, and possibly with the delete_where() bug reaching a 4.0.1 patch instead of being caught pre-release. The AI coding agents cost analysis we covered last month predicted exactly this: the economics make sense when the human is already senior, the task is well-scoped, and the model can run experiments in a real codebase rather than answering interview questions.

The Phone-and-Parade Workflow

Willison started the session in Claude Code for web on his iPhone, went out to enjoy the Half Moon Bay 4th of July parade, and occasionally checked in to prompt the next step from his phone. He switched to his laptop for the final review through GitHub’s PR interface.

This is the part that challenges the one-person unicorn framing. Willison was not replaced by Fable. He was a senior maintainer who used a frontier model to do the tedious work — reading every method, checking transaction semantics, writing documentation — while he reviewed the output and made the design decisions. The model churned for 10-15 minutes per task; he enjoyed a parade. The leverage is real. The replacement is not.

❓ FAQ

Is sqlite-utils 4.0 stable now? No — this is 4.0rc2, a release candidate. The stable release will follow after the RC gets community testing. The transaction model changes are significant enough that Willison wants real-world validation before tagging 4.0.

What was the data-loss bug? Table.delete_where() ran its DELETE without a transaction wrapper, leaving the connection in an uncommitted state. Subsequent writes and even new table creations could be silently lost on close. Fable identified it as a “release blocker” in its initial review.

Does cross-model review actually work? Willison reports it does. GPT-5.5 found two transaction-handling bugs that Claude Fable had missed. The pattern — Anthropic’s model reviews OpenAI’s work and vice versa — is now part of his standard workflow.

What does this mean for software jobs? It means the senior engineer’s job is shifting from writing code to reviewing code, designing architecture, and deciding what to ship. The Fable 5 kernel write-up and the Airbnb 60% AI-code report point the same direction. The leverage is increasing. The floor for entry is rising.

🔍 THE BOTTOM LINE

Simon Willison just shipped a production release candidate mostly written by an AI, reviewed by a rival AI, for $149.25. The bug Fable caught would have corrupted user databases. The bugs GPT-5.5 caught would have broken documented behaviour. Neither was a hallucination. The cross-model review pattern — Anthropic writes, OpenAI checks, human decides — is now a verified production workflow, not a demo. The question is not whether this scales to the rest of the industry. It is how fast.