Every line of shipped code has an owner who is accountable for it, and that was true long before agents entered the picture. What agents have really changed is the volume of code. It now arrives faster than anyone can read it, and the traditional safeguard of a reviewer approving each diff was never as dependable as teams assumed. John Crickett, founder of Coding Challenges and a software veteran of several decades, explains on The Next Commit why delivery pressure is pushing developers to stop reading the code they ship, and why the reviewer approval they leaned on was never much of a safeguard.
Teams can't outsource accountability to an AI tool. What they can do is ensure their verification practice keeps pace with the code, instead of quietly lapsing while everyone assumes it's still happening.
Delivery pressure is quietly ending code review
Most software developers who stop reviewing AI-generated code do so under the weight of delivery pressure, not by deliberate choice. Crickett sees developers splitting into three groups as agents take over more of the writing:
- One group has stopped reading the code and trusts the agent.
- A second group still reads everything because, as Crickett puts it, they "feel that they've got to own anything that goes to production."
- The third group is under pressure to ship, and Crickett says those developers either aren't reading the code "as fully as they'd like" or feel they're "losing the ability to."
That third camp is the one worth worrying about, because those software developers ran out of time to review rather than deciding review doesn't matter. When review slips under that pressure, changes merge that nobody fully understands, and the next person to maintain the code inherits a system they cannot explain. Crickett is blunt about what that costs. "If you never look at the code or you don't have the ability to…You don't know whether it's good." Teams absolve themselves of accountability in the distance between the camp they want to be in and the camp delivery pressure forces them into.
Neither a human reviewer nor another model can serve as the sole safeguard
The review process that agents are supposedly breaking was already broken. Crickett walks through the honest math of code review: a reviewer easily scrutinizes five lines, finds 50 lines a bit harder, but a 500-line change “just gets a LGTM. Because most people cannot hold in their head five hundred lines of complex code change.” That approval is supposed to make the reviewer accountable for the change, and host Tom Howlett and Crickett both call that idea “a bit of a myth,” since nobody can answer for code they couldn’t follow. Crickett doesn’t fault the reviewer, because large pull requests are hard for anyone, and he calls it unrealistic “to expect that human code review works…We miss things and it doesn’t scale.” Agents turned the occasional 500-line change into a daily one.
Pointing another model at the problem helps, and Crickett values LLM code review because it is cheap and repeatable. "If a human might only catch half the issues in a code review, an LLM might only catch say a third of the issues. The difference is the human will spend hours doing it and hates doing it. The LLM will spend minutes doing it and you can run it again. You can clear its context."
Research on LLM judges shows where to draw the line. Ask one the same question twice and some of its verdicts change, and push back on it with another AI and more of them flip, because these models are trained to please. An LLM that catches a third of issues in minutes adds real value inside the loop, and the same LLM working as the only quality gate becomes a liability.
Confidence needs both kinds of code verification
Even as AI agents improve, the need for code verification is essential— an agent can write excellent code that still misses what the system needs. "It could write amazing code better than any human, for argument's sake, but still does the wrong thing," Crickett says. Suppose the agent ships flawless code that stores data insecurely, your site gets breached, and personal details leak. Nobody wrote bad code in that scenario, but someone left a gap between what they intended and what they specified, and the agent filled it without saying so. Those gaps open up easily in natural language, where, as Crickett points out, "you can change the whole meaning of a sentence by putting a comma in or not putting a comma in." A check that only asks "is this code well written" passes that change every time.
Crickett's own answer is a "multi-point approach" that pairs LLM review with static analysis, compiler checks, tests, and exploratory testing, and a mix like that builds confidence when teams know what each check can prove. Deterministic analysis proves what rules can check: syntax and style, data and control flows, taint, architecture, and dependencies. It returns the same verdict every run and holds its answer when an agent argues back. This is what Sonar calls a zero-trust, multilayered code verification strategy: AI code review works alongside static analysis, compiler checks, tests, and exploratory testing.
Agentic verification covers what rules can't, reasoning about intent and business logic, which is the check the breach scenario needed. Both kinds need to run independently of whatever generated the code, so every change meets the same bar whichever agent or model wrote it, and both need to leave evidence, a record of the intent, the standards, the checks, and the result that an auditor can read. In the CI verification loop, SonarQube sets the standard and Gitar enforces it at merge speed.
Teams that want to stay in the camp that can still answer for what ships need verification built into every loop, from the guardrails that guide agents as they write to the checks that gate every pull request, because willpower and heroic review hours can't keep up with agents. Code is abundant. Confidence is scarce. Teams have to engineer it into every change.
Listen to the full conversation with John Crickett on The Next Commit, and rethink how verification scales across your own development loops.

