When lines shipped stopped meaning anything
The metric had always been a rough proxy for effort and progress. An agent that writes a thousand lines in a minute severed the connection entirely.
When lines shipped stopped meaning anything
A VP of engineering at an enterprise company told me they had to retire a metric they had relied on for years, because it had started actively lying to them. They had long used output volume, lines changed, commits, pull requests, as a rough gauge of how much work was happening and how much progress the team was making. It was never precise, everyone knew that, but it correlated well enough with effort and value to be useful. Then the team adopted AI tools, and an engineer could now generate a thousand lines in a minute. The metric spiked, and the spike meant nothing. The connection between code volume and effort, and between code volume and value, had been quietly holding the metric up, and the tool severed both.
The old metrics rode on a broken assumption
Output-volume metrics were never good, but they were useful, because they leaned on two assumptions that mostly held. First, that producing code took effort, so more code meant more work. Second, that code was roughly proportional to value delivered, so more code meant more progress. Neither was exactly true, but both were true enough that a manager could glance at output volume and get a real, if rough, signal.
AI tools break both assumptions at once. Producing code no longer takes much effort, so code volume no longer tracks work, an engineer can generate a huge diff with a short prompt. And more code is not more value, in fact generated code often includes bulk that a person would not have written, so volume can rise while value stays flat or the codebase gets worse. The two links that held the metric up are both cut, which means the metric now measures something close to nothing, or worse, rewards exactly the wrong behavior, producing more code regardless of whether it should exist. A team steered by output volume in an AI world is steering by a broken instrument that reads high precisely when it should read caution.
This is not a small tuning issue. It is the failure of a whole category of measurement. Anything that counts code volume as a proxy for effort or value has lost the relationship that made it a proxy, and continuing to use it does not just give a weak signal, it gives a misleading one, encouraging the generation of code as an end in itself.
Measure outcomes, not volume
The lesson is that once AI severs the link between code volume and both effort and value, the team has to measure the outcomes it actually cares about, not the volume that used to stand in for them. The volume metrics are not just less useful now, they point the wrong way, and they have to be replaced, not adjusted.
What teams measure once volume is meaningless.
- Outcomes delivered, whether the work moved the results the team is responsible for, not how much code it took.
- Quality and reliability, whether what shipped works well and holds up, since volume says nothing about this.
- The health of the codebase over time, whether it is getting easier or harder to change, which volume actively obscures.
- Whether the team understands what it shipped, since a large diff nobody grasps is a liability, not an achievement.
- Cycle time to a working, trusted outcome, which captures the real bottleneck now that writing is cheap.
The point is to measure the destination, not the distance traveled, because AI made distance cheap and the destination is all that ever mattered.
How we think about it at Density Labs
The output-volume metric that suddenly lies is one of the first casualties of AI adoption, and many teams keep using it well past the point where it means anything, because it is familiar and it still produces a number. The number now rewards generating code for its own sake, which is close to the opposite of what the team wants, and steering by it pushes the team toward volume and away from value.
When we help a team adopt AI tools, retiring the volume metrics is often an early step, because a team measured on code produced will produce code, and that is no longer the goal, if it ever was. We shift the measurement to the outcomes and the health that actually matter, so the team is steered toward value instead of toward volume.
Lines shipped was always a rough proxy for value. AI made it a proxy for nothing, and a metric that measures nothing is worse than no metric at all.