# Why Experienced Developers Are Wary of Agentic Development Building software is not the same as maintaining reliable systems in production environments. - **Source:** [Martin Fowler](https://martinfowler.com) - **Published:** 2026-10-29 - **Topic:** [Software & Engineering](https://brifing.si/c/engineering) - **Original article:** - **On Brifing:** https://brifing.si/s/fa462a90-e0a6-437b-86c2-e8566625ea23 ## The Production Reality Gap Experienced developers understand that functional code is not equivalent to production-ready software. While coding agents can generate massive volumes of logic, they often lack the nuanced understanding of long-term maintainability. Senior engineers remain cautious because they have personally managed 3am production failures, knowing that stability requires more than just successful compilation. ## The Value of Human Judgment After decades in technology, senior developers provide wisdom that AI models currently struggle to replicate. They recognize historical patterns, identify organizational bottlenecks, and challenge underlying technical premises. This human judgment is not a barrier to progress but a necessary guardrail, ensuring that systems are built to evolve rather than just execute. ## The Whiteboard Experiment A recent Thoughtworks experiment involved building an airline application entirely through agents. The team discovered that human effort shifted from typing code to intensive whiteboard sessions. They spent two-thirds of their time defining domain boundaries and designing feedback loops, proving that human oversight remains the primary driver of complex software architecture. ## Redefining the Developer Role In the agentic era, developers act as architects of the harness rather than manual coders. By designing tests, contracts, and delivery pipelines, they provide the necessary constraints for agents to function safely. This shift requires a new skill set focused on directing autonomous systems while maintaining rigorous standards for system reliability. ## The CI Pipeline Challenge The experiment revealed that agentic output frequently breaks continuous integration, leading to constant red builds. This instability undermines the core purpose of CI, which is to provide confidence in code changes. If developers stop trusting the build status, the entire feedback mechanism fails, necessitating a fundamental rethink of automated delivery pipelines. ## Stability Versus Throughput DORA’s 2025 research indicates that while AI adoption increases delivery throughput, it often correlates with lower delivery stability. This creates a paradox where teams move faster but encounter more frequent production issues. Addressing this gap requires integrating DevOps principles more deeply into the agentic workflow to ensure safety remains prioritized. ## Batch Size and Complexity Many teams are shifting from small user stories to larger epics to leverage agentic speed. However, this increased batch size creates significant pressure on CI pipelines and parallel testing environments. Developers must determine if current infrastructure can handle these larger units of work without sacrificing the modularity required for safe deployments. ## Navigating Unknown Territory Agentic development is currently like a backcountry ski trip across uncharted terrain rather than a groomed slope. There are few established best practices, and the feedback loops for success are slow. Experienced developers are not laggards; they are simply asking for a map before rushing into an environment that lacks proven safety. ## The Staging Fallacy As industry experts often note, staging environments are merely glorified laptops. Only production reveals the true behavior of a system under load and real-world change. Developers remain skeptical of agentic code until it has survived multiple production cycles, as they know that 'it works on my machine' is a dangerous illusion. ## Leadership and Experimentation Leaders must distinguish between genuine technical concerns and simple resistance to change. Effective management involves providing developers with the time and permission to fail during experiments. Success should not be measured by the volume of code produced by agents, but by the team's ability to define safe, repeatable development patterns. ## The Path Forward The future of software engineering lies in combining the speed of agents with the seasoned caution of experienced developers. By bringing their expertise into the experimentation process, developers can help map this new territory. Their skepticism is the essential ingredient for building systems that are not just fast, but truly reliable. ## Sources covering this story - https://martinfowler.com/rachels-ramblings/good-devs-wary.html — --- _Summary written by Brifing from the original reporting. Copyright in the original article belongs to its publisher; read the full piece at the link above._