Why are good developers so wary of agentic development?
Experienced programmers are debating whether AI “agentic” coding tools enhance or erode software quality and developer skill. Many praise agents for dramatically speeding up routine implementation and debugging, but warn that delegating too much design and coding work can destroy mental models of a system, encourage shallow review of large code changes, and shift humans into low-context QA roles. Others argue that careful use of agents by strong engineers, backed by solid tests and observability, can be a competitive advantage, while overreliance by less skilled teams risks fragile, poorly understood systems and long‑term degradation of expertise.
Why wariness?
- Many argue wariness is based on experience, not fear: current agents often produce code that “works” but is brittle, incoherent, or hard to reason about.
- Concern that agentic development undermines the very process that creates strong developers: practicing design, debugging, and architectural thinking.
- Some liken it to offshoring: short‑term gains, long‑term erosion of local expertise.
Code quality, risk, and mental models
- Senior devs emphasize that “built” ≠ “production‑ready”: a single subtle bug can cause major incidents, and agents can generate such bugs faster.
- Hand‑writing code forces clarification of requirements and tradeoffs; delegating to agents lets the model silently resolve ambiguities and make architectural choices.
- Large auto‑generated diffs (e.g., 3k‑line PRs) are hard to truly review; developers lose a deep mental map of the system and become dependent on the agent for every change.
Trust, accountability, and dependencies
- Some say they don’t trust code they don’t understand, but others note we already trust opaque layers: compilers, operating systems, vast dependency trees.
- Counterpoint: OSS libs have community reputation, history, and shared scrutiny; an AI‑generated snippet is a one‑off with no track record.
- Debate over “network of trust”: who is accountable when an agent wrote most of the code? Some argue accountability still rests with the human committer; others worry responsibility becomes diffuse.
How and when agents help
- Broad agreement that LLMs are powerful tools for: small, well‑scoped tasks, bug‑hunting, upgrading APIs, boilerplate, derivative features, and quick experiments.
- Several claim the “best” devs use agents aggressively but keep tight control: they specify architecture, tests, and guardrails, then verify outputs.
- Others report agents are more useful in unfamiliar domains than in areas where they already have deep expertise.
Adoption patterns, culture, and longer‑term concerns
- Split views: some see resistance as stubbornness or identity threat; others see full‑throttle agentic use as reckless “vibe coding.”
- Worries about a culture of “if it passes tests, ship it,” over‑specified AI‑written tickets, and managers pushing agents to “go faster” while devs still own the fallout.
- Long‑term fears include skill atrophy, training‑data degradation, and a flood of low‑quality “slop” code; optimists foresee stronger testing/observability harnesses making implementation details less critical.