With coding agents, the key developer skill shifts to verification

The main bottleneck in deploying coding agents is not how much text they can generate, but whether a human can verify the result. According to Simon Willison, developer competence is shifting from writing alone to clearly instructing a change and then confidently confirming that it was applied correctly.

Line-by-line review is not enough on its own

Traditional code review assumes that one person reads another person's work one line at a time. With agent-generated changes, the same approach quickly becomes exhausting and difficult to scale. Willison notes that reviewing every line is sometimes appropriate, but it has never been the most effective way to validate a software change.

Systemic verification therefore carries more weight. Strong test suites, isolated builds, and architectural guardrails make it possible to inspect the behavior of a change, not only its syntax. Speeding up code generation by dozens of percent does not accelerate development if the bottleneck merely moves to the review phase.

Legacy projects expose weak verification

The greatest risk appears in older projects without reliable test coverage. If an agent works in unbounded territory and human inspection is the only control, subtle logic errors can reach production. Reading unfamiliar code also demands a different kind of concentration from writing a change from scratch.

Those projects first need stronger boundaries within which results can be verified. Without them, faster generation merely shifts the work into a longer and less certain review. The team paradoxically spends more time hunting for hidden bugs than they would have spent writing the code manually.

Test results become the primary review surface

Model benchmarks will still matter, but tools for visualizing changes and automating verification will be just as important in daily work. Teams that move some attention from reading lines to evaluating tests and system behavior can review a larger volume of changes with greater confidence.

This does not mean giving up on reading code. It means using code reading where it provides the most information and supporting the rest of the evidence with repeatable checks. Greater agent autonomy requires proportionately stronger automated oversight.

Instruction and verification merge into one discipline

Willison frames productive agent use around two kinds of confidence: a developer must be able to specify a change precisely and then verify that it was applied correctly. As changes grow larger, those two activities will merge into a single engineering discipline.

Productivity will depend not only on how much code an agent produces, but also on whether a team can preserve precise intent and reliably confirm the result. That paired skill will shape how much work teams can safely entrust to agents.

Lilith's verdict

Syntax generation is getting faster, but humans still pay the bill for confidence. A machine can write the change, yet it has not taken responsibility for proving the change is right.