Technology
AI code review is driving top engineers toward the exit
As teams embrace AI-generated code, senior engineers are spending less time building and more time verifying—leading to burnout and departures.
The New Stack
Top-tier engineers are increasingly frustrated with a shift in their role: they're now spending their days reviewing machine-generated code instead of writing their own. Teams adopting AI heavily are merging 98% more pull requests while review times have jumped 91%, placing unsustainable burden on the engineers who care most about code quality.
The review workload crisis#
Engineers across senior levels report they now dedicate far less time to actual coding, having redirected it toward validating AI output. One study found 77% of engineers spend less time writing code than before. The irony is that those shouldering this burden aren't AI skeptics—they're early adopters who championed the technology and built strong review cultures. Now they face queues of 15 pull requests daily, each containing hundreds of lines.
Some experienced engineers have begun refusing to review AI-generated code outright, citing exhaustion. Engineering leaders report that code review bottlenecks rank among their most pressing operational concerns.
Why AI code is uniquely hard to review#
When human colleagues write code, reviewers can trace intent through explanations of tradeoffs, rejected alternatives, and constraints. With AI-generated work, that context vanishes entirely. Reviewers face reverse-engineering intent purely from diffs—a fundamentally different and far more cognitively demanding task. The problem deepens because much AI code looks plausible at first glance, passing basic checks while harboring subtle flaws.
Common problems include:
- Plausible but wrong: Code handles the happy path coherently but fails on edge cases, requiring reviewers to infer unspoken requirements
- Over-engineered: AI models produce elaborate abstractions and enterprise patterns for problems needing just 15 lines
- Convention-blind: Generated code ignores your team's naming, error handling, logging, and module boundary conventions
- Confidently hallucinated: Nonexistent APIs, deprecated methods, and invented config options sometimes slip past immediate review
- Cargo-cult patterns: Retry logic where retries don't apply, circuit breakers for sync calls, error handling disconnected from actual failure modes
All of this reads like legitimate code, making it taxing to catch at scale.
