Every engineering team I talk to has a version of the same story this year. Someone demos an AI assistant generating a full CRUD service in ten minutes, the room gets excited, and a quarter later the team is shipping more code than ever while spending more time fixing it.
The data backs this up. Google's 2024 DORA report found that as AI adoption increased, delivery throughput fell an estimated 1.5% and delivery stability fell an estimated 7.2%. GitClear's analysis of 211 million changed lines of code, covered by LeadDev, found an 8-fold increase in duplicated code blocks in 2024. And in the 2025 Stack Overflow Developer Survey, 84% of developers said they use AI tools, while 46% said they don't trust the accuracy of the output, up from 31% a year earlier.
None of this means AI coding tools are bad. It means speed without judgment just moves the bottleneck from writing code to fixing it.
Where AI genuinely saves time
In our own delivery work, AI handles the parts of the job where being wrong is cheap and easy to spot:
- Boilerplate: scaffolding, DTOs, API clients and config
- First-pass unit tests and test data
- First drafts of specs, docs and commit messages
- Flagging likely bugs and code smells for a human to check
On these tasks, the time savings are real. A spec that used to take three to five days can be drafted the same day. Boilerplate that took two or three days now takes a few hours. Test scaffolding goes from a day or two to minutes.
Where it still needs a senior engineer
The expensive mistakes happen where the model can't see the whole picture:
- Architecture: service boundaries, data models, and what will or won't scale
- Security: auth flows, secrets, input validation and dependency risk
- Edge cases: the unusual customer, the time zone, the partial failure
- Business logic: rules that live in someone's head, not in the repo
An assistant will happily generate code that compiles, passes the tests it wrote for itself, and is still wrong for your business.
A simple operating model
These are the rules we work by:
- AI drafts, humans decide. Nothing generated goes to main without a named reviewer.
- Review design, not just syntax. Reviewers ask "should this exist?" before "is this correct?"
- Fight duplication on purpose. If the assistant produced a near-copy of existing code, refactor it into a shared function in the same pull request.
- Keep batches small. The DORA team's own advice is that AI helps most on top of small batch sizes and solid testing. Huge AI-generated pull requests hide problems.
- Measure stability, not just speed. Track change failure rate and time to restore alongside velocity.
What changes on the team
Junior engineers paired with AI produce more drafts. Senior engineers spend more of their week reviewing and designing, and less of it typing. Review time goes up as a share of the work, and that's the point. On our projects, this split has let us ship production software roughly twice as fast without the stability drop the industry numbers warn about.
The takeaway
AI is the best junior pair programmer most teams have ever had. Treat it like one: fast, tireless, and in need of supervision. Speed gets you to market. Senior engineering judgment keeps you there.
Where does your team draw the line between generated code and human review?
