My agent shipped 35 commits in one day. Here's what I had to fix.

I scanned the git history of dstar, the Elixir/Phoenix library I maintain that wraps Datastar. Out of 105 commits, 66 are agent-involved — 63 percent. And about 35 of those landed on a single day, 2026-06-11, building the entire Dstar.Page layer.

The first reaction to that number is “wow”. The second, more useful reaction is “so what did that actually cost me?”

What landed that day

Dstar.Page is not a toy. It is the layer that lets you write a Datastar-powered page as a plain module — mount, render, handle events, stream updates — instead of hand-rolling SSE plumbing in every controller. A whole architectural layer, written and committed in one day. A year ago that is a week of work, minimum, assuming I did not get distracted.

The agent did not get distracted. That is the honest pitch for this way of working, and it is real.

The bit nobody puts in the demo

Here is the split that people leave out: the agent did the writing, and I did the judgment. Three kinds of judgment, over those 35 commits.

Catching the one that mattered. Buried in the pile is a commit titled “Fix SSE frame injection via carriage returns (S1)”. SSE frames are line-delimited. A raw carriage return that finds its way into the data can break the frame boundary, which means content is no longer inside the frame it was supposed to be inside. That is a real security-shaped problem, and it did not announce itself. It was one line item among thirty-five, and if I had been tired and skimming I would have scrolled past it.

Walking back a false alarm. Another commit reads: “Retract the connect() placement warning — it was not a real bug”. The agent had added a warning for a placement problem that looked suspicious and was not actually wrong. Shipping that warning would have sent every user chasing a bug that does not exist — a slow tax on strangers. Retracting it was more work than shipping it, and the retraction is the commit I am proudest of.

Fixing the subtle thing the review caught. Two more, both about the same mechanism:

Give the page first refusal on the takeover signal Fix a stale takeover signal poisoning the next stream (review F1)

Note the label on the second one. The review finding has an ID in the commit message, which means somebody — me, with a checklist — went through the streaming path and found a failure mode that no test was going to surface on its own.

Correcting the confident documentation. “docs: correct CSRF story — Datastar has no built-in meta-tag handling”. An agent wrote a plausible claim about how CSRF works in this stack. It was wrong. Docs are where confident wrongness survives longest, because nothing fails and nobody re-reads them until a stranger is confused.

Why volume stopped being the metric

Thirty-five commits is not thirty-five units of progress. It is thirty-five units of output, and output is cheap now. What is not cheap is checking it.

That day, the agent generated work faster than I could verify it. The bottleneck moved from the keyboard to my ability to read and decide, and it has not moved back since. I can measure the output in a git log. I cannot measure the review in anything except the bugs that did not happen.

So the useful question is not “how much did it ship?” It is “how much of it did I actually read?”

What I actually had to be good at

1. Defining done before the work started. Vague instructions produce confident, well-formatted, wrong answers.
2. Reading the diff, not the summary. The summary is marketing. The diff is the truth.
3. Throwing away finished work without drama. The retracted warning was a day’s worth of output that had to go. That is not failure. That is the job.
4. Spotting the one thing in thirty-five that actually matters. The carriage return fix did not come with a warning label. It looked like everything else.

The honest bottom line

The agent shipped a whole layer in a day. I spent a good chunk of the following days deciding which parts of it were true. Two of those parts were a false alarm I had to undo, and one was a framing bug that had real security shape.

That trade is still a good deal — better than a good deal, on the days it works. But do not count the commits. Count the ones you verified, and notice how small that number is. That gap is where the job lives now.