I’ve been thinking a lot lately about how we measure productivity in software development, especially now that coding agents can generate thousands of lines of code in hours. The conventional wisdom says lines of code is a meaningless metric. But I’m here to argue that’s only half right.
The old rule of thumb was straightforward: a skilled engineer produces maybe 200 lines of production-ready, debugged code on their best day. Most days? Fifty or sixty lines. That’s the baseline. If you could somehow produce a thousand lines of debugged, maintainable, tested code daily, that’s a meaningful improvement. Full stop. The metric only becomes useless when you pretend the code quality doesn’t matter, but with the right discipline, agents can maintain that quality.
The Paradox of Individual Productivity
Here’s where it gets interesting. With agents, I can now produce code maybe a hundred times faster than before. Which raises an obvious question: why should any company employ more than one engineer?
The knee-jerk answer is the bus factor, sure. But there’s something deeper. The limiting factor has shifted. I can churn out code at incredible speed, but I don’t have the cognitive capacity to stay on top of a hundred times the amount of code. The bottleneck moved from hands to brain.
This means teams are more necessary than ever, just for a different reason. We’re not load-balancing coding speed anymore. We’re load-balancing cognitive capacity. Someone needs to think about architecture. Someone needs to understand why that feature exists. Someone needs to remember the decisions made six months ago.
That’s the work AI still can’t do well.
The Winchester Mystery House Problem
One of my favorite concepts from Fred Brooks’ The Mythical Man-Month is conceptual integrity. Good software has it: no surprises, consistent design patterns, everything fits together. It covers the right domain and no more.
Coding agents are basically the enemy of this principle. I had a delightful conversation with Claire Giordano about this, and she nailed the analogy: the Winchester Mystery House. For 40 years, the widow of the Winchester rifle inventor kept adding rooms because someone told her not to. Now imagine that, but the cost of adding rooms just dropped from a week of work to an hour.
Suddenly, every half-baked feature idea looks reasonable to implement. That crazy edge case you’d normally dismiss as not worth the effort? Now it’s worth five minutes of prompting. Your codebase starts growing weird bumps in funny directions. You end up with software that works but makes no coherent sense.
The real cost isn’t in the implementation anymore. It’s in the future decisions you can’t make. Is this feature in scope? Should we refactor this section? Does this belong in this service? When everything was hard to build, those questions were self-answering. Effort was the enforcer of discipline.
Discipline as the New Competitive Advantage
This is where senior engineers become genuinely valuable in ways that weren’t as obvious before. A junior engineer with an AI agent can now produce code at scale. What they can’t do is maintain conceptual integrity across a growing codebase. They don’t have the pattern recognition or the experience to say no effectively.
Senior engineers know how to ask the hard questions before running the prompt. They understand scope. They can look at a feature request and decide whether it’s worth adding or whether it violates some core principle of the system.
The discipline that used to be enforced by time constraints now has to be self-imposed. That’s actually harder. It requires judgment.
For teams building with agents, this means the architecture decisions get more important, not less. You need clear boundaries between services. You need documented conventions. You need people who understand the system well enough to push back on feature bloat. Thinking about AI-first development means rethinking how you organize your team and your codebase.
The agents themselves are the easy part. The hard part is staying sane at scale. The companies that figure out how to maintain conceptual integrity while moving fast with AI will have an enormous advantage over those that just keep adding rooms to the house.
What discipline looks like when the cost of implementation approaches zero might be the defining question of the next decade of software development.