There is a strange thing happening in software development.
We can write code faster than ever.
AI can generate an API, create database models, write tests, refactor a component, explain an error, and even open a pull request before you finish your coffee.
So why do some engineering teams still feel slow?
Because writing code was never the only bottleneck.
The Code Is Getting Faster. The System Isn't.
Imagine a developer who used to take four hours to implement a feature.
With AI, they can produce the first version in one hour.
Sounds like a 4x productivity improvement.
But then comes:
- 45 minutes of code review
- 30 minutes fixing incorrect assumptions
- 20 minutes updating tests
- 30 minutes debugging an edge case
- 40 minutes waiting for CI
- Another review after changes
- A production issue two days later
Suddenly, the one-hour implementation wasn't a one-hour feature.
AI accelerated code generation. It didn't automatically accelerate software delivery.
This isn't just theoretical.
DORA's research found widespread AI adoption and strong perceived individual productivity gains, while also highlighting tensions around delivery performance and stability.
The New Bottleneck: Verification
As AI becomes better at creating software, developers increasingly become responsible for verifying software.
That means asking:
Does this actually solve the problem?
Not:
Does this code look correct?
Those are very different questions.
AI can produce beautiful code that solves the wrong problem.
It can confidently use an API that doesn't exist.
It can write a test that validates its own incorrect assumption.
It can introduce an abstraction that nobody on the team needs.
And it can make a 20-line problem into a 200-line solution.
The Most Dangerous AI Code Is Not Bad Code
It's code that looks good enough to merge.
Bad code is easy to notice.
Confusing code gets rejected.
Broken code fails tests.
But plausible code can quietly enter production.
A 2026 study examining more than 300,000 AI-authored commits across thousands of GitHub repositories found hundreds of thousands of AI-introduced issues, with 24.2% of tracked issues still present in the latest revision studied.
That doesn't mean AI-generated code is bad.
It means something more important:
AI-generated code still needs engineering.
So What Should Developers Do?
Don't stop using AI.
Change what you measure.
Instead of asking:
"How much code did AI generate?"
Ask:
- Did we ship faster?
- Did production stability improve?
- Did review time decrease?
- Did bugs decrease?
- Did developers spend more time solving meaningful problems?
- Did maintenance become easier?
- Did customers actually get value faster?
Because 1,000 generated lines that create 10 hours of review work aren't necessarily productivity.
They're just faster typing.
The Developer's Job Is Changing
The strongest developers in an AI-assisted world may not be the ones who can prompt the best.
They'll be the ones who understand:
architecture + business requirements + debugging + security + testing + system behavior.
AI can generate implementation.
It cannot remove your responsibility for the outcome.
That distinction is becoming extremely important as AI moves from autocomplete toward agents that can make multi-step changes across a codebase.
The developer increasingly becomes the person who says:
"Here's what we want."
"Here's what the AI produced."
"Here's why we should—or shouldn't—ship it."
A Simple Rule I Want to Follow
Before merging AI-generated code, ask three questions:
1. Would I understand this code six months from now?
If not, simplify it.
2. Can I explain why every important decision was made?
If not, investigate it.
3. What happens when this code is wrong?
If the answer is "we'll find out in production," we have a process problem.
The Real AI Productivity Metric
Maybe the future of developer productivity isn't:
Lines of code per developer.
Maybe it's:
Useful outcomes per unit of engineering effort.
That's a much harder metric.
But it's also a much more honest one.
AI is giving developers an incredible opportunity.
We can spend less time typing boilerplate and more time thinking about difficult problems.
But only if we resist the temptation to turn every productivity gain into more code.
Sometimes the best use of AI isn't generating 500 lines.
It's helping you realize that you only needed 50.
What do you think?
Has AI actually made your team faster from idea → production, or has it mainly made code generation faster?
I'd especially like to hear from developers who have been using AI coding tools for 6+ months.
