Report · martinfowler.com
Why are good developers so wary of agentic development?
martinfowler.com
Source published October 29, 2026
Summary: 2 min read
50/100
Summary
Experienced developers’ caution about agentic software development reflects uncertainty over whether AI-generated systems will remain safe, maintainable and reliable in production, according to Thoughtworks’ Rachel Laycock. Coding agents can generate software quickly, but teams still need to determine behavior, domain boundaries, failure handling, testing, architecture checks and delivery controls. Laycock distinguishes reluctance to hand agents full control from reluctance to use coding assistants. Thoughtworks Regional CTO for Europe Giles Alexander led an experiment in which senior engineers, infrastructure consultants and product staff built an airline application using agents for all code generation. The teams estimated that they spent about half their time defining the domain and plans at a whiteboard and half building a harness of tests, contracts, architecture checks and pipeline controls. The application reached roughly 80% completion, but its build was frequently red despite the application running locally. The teams did not determine whether parallel agents, insufficient modularity, faster changes than checks could complete, or several factors caused the instability. DORA’s 2025 research found AI adoption associated with higher delivery throughput but lower delivery stability. Laycock argues that heavily agent-built systems need time in production and through later changes before teams can judge their reliability, and calls on leaders to give experienced developers room to test and revise development practices.
Key Takeaways
- Experienced developers may accept coding assistants while resisting autonomous agents that execute software work without sufficient guardrails and human judgment.
- Thoughtworks teams using agents for all code generation spent substantial time on domain design and on tests, contracts, architecture checks and delivery-pipeline controls.
- A Thoughtworks agentic-development experiment produced an application that ran locally but had a frequently failing build, undermining confidence in continuous-integration signals.
- DORA’s 2025 research linked AI adoption with higher delivery throughput and lower delivery stability.
- A system built largely by agents cannot be judged reliable solely by local or staging results; its behavior in production and through subsequent changes remains consequential.
What the discussion said
The thread largely rejects the premise that strong developers are simply afraid of agents. Many describe a pragmatic middle ground: agents can accelerate bug hunting, API-upgrade research, unfamiliar libraries, and cross-team work, but experienced engineers keep ownership of architecture, constraints, review, and production outcomes. In that framing, the valuable skill is not refusing AI or surrendering to it; it is knowing where to delegate, where to stop the agent, and how to verify what returns. The caution is rooted less in craft nostalgia than in operational memory. Commenters point out that an agent can generate code that passes narrow tests while embodying false assumptions, poor structure, or small shortcuts that compound into outages and security failures. Hand-writing early parts of a system also builds the mental models needed to choose data structures, evolve designs, and debug later failures. Several readers worry that outsourcing this thinking turns AI into a crutch and weakens the pipeline that develops capable engineers. Others argue that unreadable implementation has always existed beneath compilers, dependencies, and abstractions, so the answer is stronger guardrails rather than compulsory trust in source. Proposed safeguards include tests, static types and effect systems, behavioral probing, and explicit human accountability. The strongest consensus is that autonomous execution is not yet trusted; supervised, deliberately bounded AI assistance already is.
Where opinion split
The sharp divide is whether agentic coding is a productive new abstraction or an abdication of engineering judgment. Supporters argue that robust automated constraints can make code trustworthy without humans understanding every implementation detail, much as prior abstraction layers did. Skeptics answer that agents still make confident conceptual errors, and only engineers with a real model of the system can recognize failures that tests and local checks miss.
Coverage & discussions
Hacker News · martinfowler.com
Community discussions
Community Sentiment
Positives
- Agents are already speeding up bug discovery, dependency and API-change research, and unfamiliar-code exploration, turning tedious investigation into a much faster feedback loop.
- The strongest developers appear to get leverage by assigning bounded tasks to agents while retaining architectural decisions, review gates, and production responsibility.
- Compile-time permissions, strong type systems, behavioral testing, and monitoring agents could shift trust from manually reading every line toward enforceable system guarantees.
- For newcomers in unfamiliar domains, agents can act as an interactive learning aid by exposing plausible approaches and mistakes worth interrogating.
Concerns
- Agents routinely make confident wrong assumptions and produce code that merely passes local checks, leaving maintainers to inherit design debt disguised as completion.
- A tiny generated shortcut in parsing, configuration, or feature-flag behavior can join other small mistakes and trigger severe production incidents at machine speed.
- Letting AI perform all the thinking erodes the mental models engineers need to select architectures, diagnose failures, and improve a system over successive iterations.
- Unreviewed agent output weakens clear ownership: someone still answers for the outage, even when the implementation came from a prompt rather than deliberate engineering.
