I’ve been thinking a lot about how we measure productivity in software engineering, especially now that coding agents can generate working code at speeds that would’ve been unimaginable five years ago. The conventional wisdom says lines of code is a meaningless metric. I actually think that wisdom needs updating.
Here’s my argument: there’s a hard ceiling on human code production. Before agents, a senior engineer might produce 200 lines of production-ready, debugged code on a really good day. Most days? Maybe 50 or 60. That’s not laziness. That’s the reality of writing code that actually works, handles edge cases, and won’t explode in production six months later.
When agents let you produce a thousand lines of debugged code, that’s genuinely meaningful. The caveat is crucial: the code has to maintain the same quality bar. It needs to be maintainable, tested, and coherent. You can get there with agents, but it requires serious skill and knowledge. That’s what separates junior from senior engineers in the age of AI.
The Cognitive Bottleneck Nobody Talks About
This productivity shift creates an interesting problem. If I can churn out code a hundred times faster, why does a company need more than one engineer? Beyond the obvious bus factor (a solo team is catastrophically bad design), the answer is refreshingly honest: cognitive capacity.
I don’t have the mental bandwidth to understand and maintain a hundred times more code. The bottleneck isn’t code generation anymore. It’s comprehension, decision-making, and architectural coherence. That’s why you still need teams. You need to distribute cognitive load across multiple people who can keep each other honest about design decisions and system complexity.
This reframes how we should think about engineering teams entirely. Instead of measuring individual productivity by velocity, we should be measuring team productivity by how effectively we can maintain conceptual integrity at scale.
The Winchester Mystery House Problem
There’s a concept from The Mythical Man-Month called conceptual integrity: well-designed software has an internal logic to it. Everything fits. There are no surprises. The domain boundaries make sense.
That’s getting harder with agents. Here’s why: features used to cost time. You’d have an idea and think, “Yeah, but that would take a week. I can’t justify that.” That friction was actually valuable. It forced prioritization. It encouraged thinking before building.
Now a feature takes an hour. Maybe thirty minutes. It’s trivially easy to justify adding it. And that’s exactly how you end up with the Winchester Mystery House: 140 rooms added over 40 years, each one making sense individually but collectively creating architectural chaos.
With agents, you get the same problem but on a compressed timeline. You can add new rooms, new features, new endpoints, new data structures at a rate your codebase’s conceptual integrity can’t keep up with. Five years in, you have something that works but makes no sense. Every decision feels arbitrary. Making changes becomes a negotiation with accumulated technical debt.
Discipline is the New Limiting Factor
The old discipline was enforced by friction. You couldn’t afford to waste time, so you made thoughtful decisions. Now the discipline has to be internal. It’s a choice.
Senior engineers will thrive in this environment because they’ve internalized that discipline. They know what good architecture looks like. They know the cost of convenience features. They understand that saying no to an easy feature is sometimes the most important decision you make.
Junior engineers will struggle more, and that’s something organizations need to account for. The temptation to let agents go wild is overwhelming when the cost is so low. You need experienced people who can push back and say, “Yes, we could build that in thirty minutes, but we shouldn’t.”
This makes mentorship and code review more critical, not less. An agent can generate code faster than you can read it. But you still have to read it. You still have to understand it. You still have to decide whether it belongs in your codebase.
The real productivity gain from agents isn’t unlimited code generation. It’s giving senior engineers the leverage to accomplish more while maintaining the standards that actually matter. The question is whether your organization values conceptual integrity enough to enforce it when the friction that used to enforce it is gone.