We Priced It: What It Actually Costs to Ship AI-Written Code ($149 Case Study)

Most debates about AI-written code run on vibes: impressive demos on one side, "it can't do real work" on the other. On July 5, 2026, one of those debates got an actual invoice attached.

Simon Willison published "sqlite-utils 4.0rc2 — mostly written by Claude", documenting a real release candidate of his widely used sqlite-utils library that was largely written by an AI agent (working under the codename "Fable"), with an itemized cost of roughly $149.25. Not a toy. Not a greenfield demo. A new release of an established, real-world library, with the bill shown.

That specificity is what makes it worth studying. "AI can write code" is unfalsifiable marketing. "Here is a real release, here is what humans did, here is the $149.25 breakdown" is a data point you can reason about.

What actually happened in the sqlite-utils case study?

The short version: sqlite-utils, a mature and widely used Python library, got a 4.0 release candidate (4.0rc2) in which the bulk of the code was produced by an AI agent rather than typed by hand, and the author published an itemized account of what it cost — approximately $149.25 total — along with the process behind it.

Two things make this credible in a way most "AI wrote my app" posts aren't:

• The codebase is real and pre-existing. This wasn't an agent spinning up a fresh project with no constraints. It was work inside an established library with existing users, conventions, and expectations.
• The author is a domain expert who stayed in the loop. The release was shipped by the library's own maintainer, not handed off blind. That framing matters for interpreting the number.

For the full itemized breakdown and the step-by-step process, Willison's original write-up is the primary source — go there for the exact line items rather than trusting a secondhand summary.

Is $149 cheap or expensive for a library release?

It depends entirely on what you're comparing against, which is exactly why the number is interesting rather than conclusive.

Compared to the raw cost of a maintainer's hours, $149 in model spend is trivial — senior engineering time is worth far more per hour. Compared to "software generation is basically free now," $149 for a single release candidate of a focused library is a real, non-zero figure that scales with the work. The honest reading sits in the middle: agent-assisted development has a measurable, itemizable cost that's small relative to human labor but not zero, and that's a healthier mental model than either extreme.

The bigger point is that the cost is now legible. You can put agent-assisted development into a spreadsheet next to contractor rates and salaried hours and actually compare. That's new, and it's what turns "should we try agents?" from a vibe into a budget line.

What did the money actually buy — and what didn't it replace?

The critical nuance in this case study is that the $149 didn't buy a maintainer-free release. It bought a large share of the code production while an expert human still supplied the judgment: what to build, what "correct" means for this library, and whether the output was actually shippable.

That's the durable lesson. Agent-assisted development in its credible form isn't "no humans." It's a shift in where human time goes — from typing implementations to specifying intent, reviewing, and deciding. The agent compresses the mechanical middle; the expensive human judgment at both ends stays.

This is also why the number shouldn't be naively extrapolated. A $149 release candidate of a well-scoped library, driven by the person who knows that library best, is close to a best case. A sprawling, ambiguous codebase driven by someone without deep context would look very different — likely more model spend and more human cleanup.

Can AI write production code, based on this?

This case is strong evidence that an agent can produce the bulk of a real release of an established library, at a small and itemizable model cost, when an expert steers and reviews it. That's a meaningful "yes, under conditions."

It is not evidence that you can point an agent at any codebase, walk away, and get production software for $149. The conditions — clear scope, an expert in the loop, a mature well-understood target — are doing real work in that outcome. Read this as a proof of what's possible with good process, not a promise of what's automatic.

Why this pairs with the "agents feel dumb" problem

There's a reason this case study is worth reading alongside the broader complaint that AI agents still feel dumb in 2026. That companion piece diagnoses the problem: the bottleneck has moved from model quality to tooling and harnesses, and better models alone don't fix brittle agents.

The sqlite-utils release is the counter-example — what happens when the tooling does work and an expert drives it well. Same class of models everyone else is using; the difference is process, scoping, and a competent human in the loop. Put the two together and the message is consistent: agents deliver real, budgetable value when the scaffolding and the human judgment around them are good, and disappoint when they aren't.

Takeaways for Clawvard readers

• A real library release (sqlite-utils 4.0rc2) was mostly agent-written for about $149.25 — a rare, itemized data point.
• The cost is small versus human labor but genuinely non-zero and now legible enough to budget.
• The money bought code production, not judgment: an expert still set intent, reviewed, and decided what shipped.
• Treat it as a best-case proof under good conditions, not a universal price tag.

Deciding whether agent-assisted development is real and budgetable for your team? Start from cases with the receipts attached, and read the companion explainer on why the tooling layer — not the model — is the real bottleneck. If you want to put good agent tooling to work on your own codebase, that's what Clawvard is for.