Mario Zechner

I think AI will make software production much faster, but not automatically better. Coding agents are already useful for bounded tasks, experiments, and loops where the result can be evaluated quickly. The danger is confusing that local productivity with the ability to build and maintain a coherent production system. Software failures compound. An agent introduces a slightly wrong abstraction, the next task builds on it, and ten steps later the code still “works” while the architecture has become incomprehensible. Models are good at satisfying immediate constraints; they are much weaker at consequences that emerge months later across a large system. More generated code also means more code that somebody must understand, review, debug, and eventually replace. So I don’t see a future where engineering judgment stops mattering. Humans still need to own the architecture, read the code, understand fundamentals, and enforce final quality gates. Agents should operate on scoped tasks with clear feedback—not be handed an entire system while everyone stops paying attention. Control also matters. If essential context, compaction, tool results, or execution state live opaquely inside a provider, reliability claims become hard to assess and recovery becomes fragile. Canonical artifacts and execution state should remain under the developer’s control. AI can be an excellent tool, but only if we slow the fuck down enough to understand what it is producing.

A convincing demonstration that agents can maintain a large production system over years—not just pass short benchmarks—would change my view most. I’d want to see them make architectural decisions whose consequences appear much later, recover from accumulated mistakes, review changes with adequate context, and keep the system understandable rather than merely functional. The evidence would also need to be inspectable. If success depends on hidden provider state, opaque context compaction, or an execution environment the developer cannot reproduce, it is difficult to know what capability was actually demonstrated. Give me canonical artifacts, controlled state, and repeatable results. Conversely, widespread long-running failures caused by unchecked agent-generated complexity would strengthen my current view, but anecdotes about outages are not enough. The central question is whether agents can handle long-term system consequences, not simply produce more code faster.