AI-generated code has made production output much cheaper, while human attention and review remain limited.
2
The Z/L Continuum applies to tasks rather than engineers: critical changes need line-by-line review, while other changes can use system-level checks.
3
As agents gain capabilities and begin running loops, human judgment moves from reading every line toward deciding where proof and review belong.
Summary
Alex Volkov frames the argument over AI-generated code through two opposing conference messages. Ryan Lopopolo says code is free and engineers should move their attention toward prompts, guardrails, and systems. Mario Zechner says agents compound errors and that critical code still requires reading every line. Volkov initially treated these positions as a continuum between two types of engineer, then corrects himself: the position depends on the task. Authentication, money movement, permissions, and irreversible data need direct review. Other changes can use decomposition, traces, evaluations, shadow mode, observability, rollback, and separate agents for writing and checking. Newer systems such as Fable, Mythos, and agent loops shift the review layer again, but they do not remove the need for judgment. His conclusion is practical: engineers should ask what proof each change needs, then route the change to that level of verification.
AI engineering has moved from writing code to supervising agents
Volkov says a major change arrived in December 2025, when models began completing tasks that would take engineers more than 16 hours. He describes the resulting workflow as supervision rather than handcrafting. Boris Cherny, the creator of Claude Code, reportedly has all of his code authored by Claude Code while still shipping 20 to 30 pull requests or more. Volkov also cites Anthropic's figure that 80% of its code is AI-written, though he says the number was already a few months old. The engineer's work has moved up a layer, toward directing and checking systems that produce code.
The argument is between cheap output and expensive attention
At AI Engineer Europe, Ryan Lopopolo said, "Code is free." His advice was to focus on the prompt and guardrails that produced it, and to spend time investigating tasks where agents struggle. Mario Zechner gave the opposite warning. Agents can compound errors, delay the pain until production, and leave users to discover failures when the person who shipped the code has not read it. Zechner's rule is to let non-critical code go quickly and read every line of critical code. Volkov presents both statements as expressions of the same anxiety about how much human inspection AI-generated code requires.
The Z/L Continuum describes tasks, not fixed types of engineer
Volkov says his original framing was wrong. The continuum is real, but it applies to tasks. One engineer can take the Lopopolo approach for one change and the Zechner approach for another. Different tasks need different proof. Lopopolo's method moves attention up a layer: once a repeated mistake is found, encode it in documentation, a linter, or a review system so it is caught automatically. Zechner routes work by risk: let non-critical changes run, then read every line for critical changes. Volkov's revised question is, "What proof does this specific change need?"
Higher output has increased review and incident pressure
Volkov cites an April 2026 Faros AI survey of 22,000 engineers, which reported an 861% increase in code deletion per pull request. He also cites Anthropic shipping eight times more code per quarter than in 2025. The same discussion includes a 31% increase in pull requests merged without human or agentic review, a 242% increase in incidents per pull request, and bugs per developer rising six times over 2025. He uses Anthropic's status page as a visual example of instability, while allowing that scale or other factors may explain it. His point is direct: more output does not automatically mean more stable software.
Human review remains a bottleneck in recursive self-improvement
Volkov discusses Anthropic's recursive self-improvement essay, which describes a possible future where companies increase output by 10x, 100x, or 1,000x. The essay says human code review can become a bottleneck as more code moves through an organization, invoking Amdahl's law. Volkov notes that Anthropic and OpenAI continue hiring humans, so the human has not disappeared from the process. This creates a practical limit: even if agents can produce much more code, people still have to decide what deserves review and how that review should happen.
Verification should be routed by risk and separated from generation
Volkov's routing table puts authentication, money movement, permissions, and irreversible data in the category where engineers read every line. For critical paths, he recommends inspecting the change directly. Long pull requests should be split into atomic, reviewable pieces, and agents can help with that decomposition. He also names traces, evaluations, shadow mode, observability, and rollback. The agent that writes code should not automatically be the same agent that inspects the result and writes the tests. Volkov compares that setup to writing an exam, taking it, and grading it yourself.
Capability increases move the review layer toward task direction and loops
Volkov says capability drift changes where proof belongs without removing the need for proof. With systems such as Fable, the question may shift from whether Claude is doing the work correctly to whether it is doing the right work. He quotes Andrej Karpathy's warning that it has never felt so tempting to stop looking at code, followed by, "But don't do this in production." Volkov expects engineers to move from inspecting outputs, to inspecting task direction, and eventually to inspecting loops. The work changes as the agents improve, so the review method cannot stay fixed.
Loops automate planning and checking, but judgment remains human
Volkov describes loops as scheduled systems that discover a task, write a plan and prompt, execute the work, verify the result against the goal, and try again when it fails. This gives agents less need for human intervention, but the review has not vanished. It is hidden inside the loop. He cites Adi Olsmaniu's warning that relying entirely on automated loops to fix bugs could lower product quality and create a downward spiral. Loops raise the stakes around where engineers apply judgment. They do not make judgment unnecessary.
"Not every line in 2026 needs your eyes. Every system still needs your judgment."21:26
Who should watch
You ship code produced by agents and need a practical way to decide what to inspect yourself.
Your team is increasing AI-generated output while pull-request review and production incidents are becoming harder to control.
You are building agent loops and need to understand which parts of the system still require human judgment.
