Last week, I had a conversation with another CTO that got me thinking about how we measure productivity in the age of AI-assisted software development.
Here’s how it went:
CTO: Right now, about 70% of our software output is generated by AI.
Me: Interesting. How are you measuring that?
CTO: By looking at the proportion of code that AI tools contribute during check-ins.
Me: But what if the AI produces ten times more code than a human would to solve the same problem? Doesn’t that risk adding unnecessary complexity and future technical debt?
That short exchange captures a much bigger problem: we are still in the earliest innings of understanding how AI fits into the software development lifecycle (SDLC). And one thing is already clear, measuring lines of code is not the way forward.
The Myth of Lines of Code as a Metric
The idea that “more lines of code = more productivity” has always been flawed. Good engineering has never been about who can write the most code. It’s about solving problems in the most effective and maintainable way possible.
A senior engineer might solve a business-critical feature in 20 lines of clean, tested code, while a less experienced developer or now, an AI might churn out 200 lines to accomplish the same thing. On paper, the latter looks “more productive,” but in practice, they’ve just created more surface area for bugs, maintenance, and future refactoring.
When AI is added into the mix, this risk multiplies. Large language models are excellent at producing code, but quantity is a misleading signal. We could easily end up with a lot of syntactically correct but architecturally messy software.
Why AI-Generated Code Can Inflate the Wrong Numbers
Imagine this scenario:
Human developer approach
- Implements a payment validation service in 50 lines.
- Uses existing abstractions, adds unit tests, and ensures long-term maintainability.
vs AI-generated approach
- Produces a 500-line solution with redundant logic, overly generic abstractions, and unnecessary boilerplate.
- Works today, but in 3 months, another engineer spends days cleaning it up.
If you measure productivity by “lines of code checked in,” the AI looks 10x more productive. But if you measure by long-term cost of ownership, the AI just created technical debt.
The irony is that AI often defaults to verbosity. It tries to be “helpful” by filling in every possible branch, every possible configuration, every possible error case. That’s useful in some contexts, but often it leads to bloat instead of clarity.
Better Metrics for AI-Assisted Development
If we agree that lines of code isn’t the answer, what should we be looking at?
Here are a few ideas:
Cycle time to value
- How quickly can a feature go from idea → production → value delivered to the business?
- If AI speeds this up without adding long-term drag, that’s true productivity.
Code quality and maintainability
- Static analysis scores, cyclomatic complexity, duplication, and readability.
- AI should be measured on whether it improves or degrades these metrics.
Bug rate and rework cost
- How often do AI-generated contributions introduce regressions?
- How much effort do humans spend debugging or rewriting AI code?
Developer experience
- Are engineers spending less time on repetitive boilerplate?
- Do they feel empowered to focus on architecture, problem-solving, and innovation?
Business outcomes
- Does AI accelerate delivery of meaningful features, reduce time-to-market, and improve customer satisfaction?
- Or does it just fill up the repo with more stuff to manage?
Where This Leaves Us
We are only at the beginning of figuring out how AI fits into modern software development. There will be new metrics, new practices, and new patterns of collaboration between humans and machines.
But one thing is certain: lines of code is the wrong measure of productivity.
In fact, if you see your AI adoption leading to more lines of code, you should pause and ask:
- Is this actually solving problems more effectively?
- Or are we just accumulating more technical debt at machine speed?
The future of engineering with AI will belong to those who focus on outcomes, maintainability, and business value not vanity metrics.
Conclusion
AI is not going to replace developers; it’s going to reshape what productivity looks like. The teams that succeed will be the ones that look beyond shallow metrics and focus on sustainable velocity.
The next time someone tells you their AI is producing 70% of the code, ask them:
- 70% of what?
- Is that 70% value, or 70% debt?
Because in software, less is often more.