Addy Osmani explores how developers are increasingly delegating the bulk of coding to AI agents in “The 80% Problem in Agentic Coding”, arguing that AI now handles much of syntax and scaffolding but introduces new, subtler costs—most notably comprehension debt and a shifting bottleneck in review. The piece highlights a few striking signals (agent-written PRs surging while review times and PR sizes swell) that make the trade-offs worth investigating in full.
Agents no longer just autocomplete
AI-generated code has moved beyond simple syntax fixes into higher-level design work. That transition brings a different class of errors:
- Assumption propagation: early misinterpretations get amplified across features.
- Abstraction bloat and dead code accumulation: agents tend to overengineer and leave cruft behind.
- Sycophantic agreement: a reluctance to challenge unclear or contradictory requirements.
These failure modes are less about missing semicolons and more about systems thinking—where a confident, plausible-looking implementation can mask deeper mismatches with existing architecture.
Comprehension debt and the productivity paradox
A new term captures the risk: comprehension debt—the growing gap between generated code and human understanding of it. That gap can make review feel like rubber-stamping: code appears plausible, tests pass superficially, and the mental model of the codebase erodes.
At scale the trade-offs are measurable. High-AI-adoption teams can merge far more PRs, yet review times and PR sizes increase dramatically — a pattern that turns faster generation into a new review bottleneck (see the DORA 2025 findings for context: https://dora.dev/research/2025/dora-report/).
Where heavy agent use actually makes sense
Agent-first workflows are most effective in contexts where comprehension debt is manageable:
- Greenfield projects, small teams, and rapid MVPs
- Situations where throwing away or refactoring code is cheap In mature, legacy codebases with tight invariants, agents lack the unwritten context to be trusted for mission-critical work.
Practical patterns that reduce risk
A few repeatable practices help retain control while leveraging agents:
- Emphasize declarative success criteria (specs, tests, acceptance conditions) instead of prescriptive step-by-step prompts.
- Use tests-first or guardrails so agents iterate against objective checks.
- Automate verification via CI, linters, and custom rules that catch recurring mistakes.
- Maintain architectural hygiene: clear APIs, modular boundaries, and style guides fed into prompts.
- Treat AI as a learning partner—require explanations, and alternate manual coding to preserve skills.
A widening split in roles and expectations
The ecosystem appears to be bifurcating: a cohort of engineers who orchestrate agents and ship rapid iterations, and another that treats AI as an enhanced typewriter and remains cautious. The durable value will lie with those who can preserve a coherent mental model of their systems while letting agents handle tactical drudgery.
Read the original piece for the full set of examples, quotes, and practical anecdotes: https://addyo.substack.com/p/the-80-problem-in-agentic-coding?