$149.25 is reportedly what it cost Simon Willison to have Claude Fable write most of sqlite-utils 4.0rc2, one of the release candidates for the first major version of his database library since 2020 (3.0 was in November 2020).
The stable release landed July 7, carrying three substantial new features—schema migrations, nested transactions, compound foreign keys—and its final release candidate, rc4, was, per Willison, shaped by what he describes as "a detailed review by Claude Fable 5." The model wrote the code. The model reviewed the code. A human shipped it.
One day later, in the same tight corner of the AI-native world, Kenton Varda reportedly declared a moratorium. Not on AI writing code—on AI writing the sentences that describe code changes: PR messages, commit messages, issues, tickets.
His verdict was blunt. AI-written change descriptions were, per Willison's account, "worse than useless."
Set those two facts side by side and you have what looks like a contradiction. A practitioner will pay a model to author and audit a production library, then forbid that same model from writing a two-line commit message. If the machine can be trusted with the library, why not the sentence about the library?
The answer is not hypocrisy. It is a precise diagnosis, and it cuts to the deepest limitation of today's models—one that has nothing to do with how capable they are.
Start with why the code is safe to delegate. Code can be verified against reality. Tests pass or fail. There is a diff you can read. There is execution: you run it, and the database either migrates or it doesn't. sqlite-utils reportedly reached its 124th release with 4.0, an accumulation of behavior to check any new code against.
The model can be wrong in a thousand ways, but every one of those ways is, in principle, catchable by a mechanism outside the model. The ground truth exists independently of what the model believes.
Now look at what a change description is for. It does not describe reality; it describes intent. Its entire job is to transmit the author's higher-level framing—the why—so a reviewer can understand what the change is trying to accomplish before they wade into the how.
And this is exactly where Varda's models failed. His complaint is worth reading closely: the AI was, per Willison, "outlining details of the code that could easily be seen by looking at the code, but omitting the higher-level framing needed to understand broadly what the code is doing."
Read that twice. The model reliably produced the one thing a reviewer doesn't need—a restatement of the visible diff—and reliably omitted the one thing only the author could supply.
That is not a quality problem. It is a category problem. The model was never party to the intent. It didn't decide why the change should exist, what tradeoff it settled, what previous decision it was preserving. There was no framing inside the model to transmit, so it substituted the only thing it had: a fluent paraphrase of the code in front of it.
The model was never party to the intent. There was no framing inside the model to transmit, so it substituted the only thing it had: a fluent paraphrase of the code.
You can see the same asymmetry in Willison's own workflow, if you look at where the human stays in the loop. Willison decides. He chose to promote sqlite-migrate into the core library after three years of using it. He decided to skip rollback because, per Willison, in his experience it's rarely used. He wrote the blog post explaining that migrations are the "signature new feature."
The model wrote the code that executes those decisions. The human still owns the decisions—and, crucially, still writes the sentences that explain them.
This is the doing-versus-communicating gap, and it is more fundamental than it first appears. Doing a task can be checked against the world. Communicating intent can only be checked against a mind—and the model has no access to the mind whose intent it is supposed to convey.
Now turn to why this is spreading, and fast. The mechanism is an inversion of effort.
Leon Furze surfaces what he presents as the sharpest available definition of slop, borrowed, per Furze, via Willison: something that "takes more human effort to consume than it took to produce." The frame is economic. All communication involves an implicit bargain—the producer bears the cost of choosing words, editing, deciding what to cut, and the reader benefits from that invisible labor.
Generative AI inverts the bargain. The producer's effort drops to near zero—prompt, click—while the consumer's effort stays the same or rises, because now the reader has to sort, evaluate, and reconstruct the meaning the producer never supplied.
An AI-written change description is a pure case. It cost the author nothing and it costs the reviewer everything: they must now reverse-engineer the intent the description was supposed to carry, on top of reading the diff they were going to read anyway.
That is why it is "worse than useless." A useless artifact costs zero and delivers zero. This one costs the reviewer their time and actively misdirects them toward the details they didn't need.
And the cost compounds. As one framing of the developer version puts it, per onehorizon.ai: one person saves fifteen minutes, three other people lose an hour verifying what they were handed.
Watch what this does to a reader over time. Zvi Mowshowitz, per his post on X, describing a piece of writing he was trying to get through, reports that his "brain kept bouncing off the words." His self-diagnosis is the tell: "[constantly] scanning for and detecting AI slop is killing my tolerance for all forms of slop" (his original begins "I think").
This is the effort economy metastasizing. Once a reader has been forced to do the producer's meaning-making enough times, they start bracing for it pre-emptively—scanning every text for the tells, spending effort on defense before they've even decided whether the thing is worth reading.
The tolerance doesn't collapse for AI writing alone. It collapses for all writing at once, because the reader can no longer trust that any given sentence was produced by someone who bore the cost of meaning.
That is the quiet damage. Slop doesn't just waste the time spent on slop; it taxes the reading of everything around it.
Now zoom out to why any of this matters for a field pouring capital into agents. The industry's implicit bet is that if a model can do the task, autonomy follows—hand it the goal and let it run.
But doing and communicating are structurally different problems, and only one of them is close to solved. A model can be verified into competence at tasks with external ground truth. It cannot be verified into transmitting an intent it was never given, because the check for that lives in a human head, not in a test suite.
Even a perfectly engineered harness doesn't close this gap: it can optimize what it's told to optimize, but it cannot supply the intent it was never handed.
This is why the slop backlash is worth taking seriously as a signal rather than a taste complaint. It is coming from inside the AI-native camp—from the exact people who happily pay $149 to have Claude build a library. They are, arguably, not Luddites drawing a line at capability. They are drawing a line at legibility.
The wall that autonomy hits, on current evidence, is not that agents can't do enough. It is that we cannot understand what they've done and why—and the artifact whose entire purpose is to close that gap, the humble commit message, is the first one the practitioners took away from the machines.
That is the tell. The people most bullish on AI doing the work are the ones banning it from explaining the work. They have found the seam where the model's competence ends and its blindness begins, and the seam runs exactly along the boundary of intent.