300,000 Lines Nobody Will Ever Read

The old mental model for developer productivity was keystroke throughput — how fast can one human type the thing without stopping to think — which was always a weird way to measure it, like rating a chef by how quickly they move the knife rather than whether the food is edible.

That model is now so broken it doesn't even make sense to argue against it.

Months are now days. That's not hyperbole, that's just what's happening. The 300,000 lines that an AI generates in a session — most of them don't survive to the final product. They get written, tried, discarded, overwritten. They existed for maybe forty seconds. Nobody looks at them. Nobody should have to.

And this is where the old metric doesn't just become inaccurate, it becomes meaningless in a way that's almost philosophical — because the lines were never the thing. The thing was always the thing on the screen when you were done.

We're still in a transitional moment where people talk about "generated lines of code" as a benchmark, which is understandable — you need some unit to point at — but it's the same category error as measuring the keystroke throughput. You're counting inputs to avoid having to say what the output is worth.

Here's what I think happens next: we stop thinking in lines entirely. Not as a metaphor. Literally. The unit might be one line or it might be a million, and the human will never see it, and that will be fine, and the only question anyone will ask is whether the thing does the thing.

Andrew Ng said something this morning that lands exactly here, and I won't pretend I can improve on it — the point is that the frame has to shift from what gets produced to what gets done, and that shift is not coming, it's already happened, and the people still arguing about line counts are arguing about film grain in a streaming world.

The screen. The task. Done or not done.

That's the whole metric. It was always the whole metric. We just needed AI to generate enough throwaway lines to make that obvious.