Date: Apr 17, 2026 · Reading time: ~5 min

Audio version:

Remember that time when Elon Musk bought Twitter (now X) and promptly asked engineers to print out their code? Screenshots of their most salient lines; Then reportedly stack-ranked them by LOC (Lines of Code) written in the past year and cut the bottom tier (around 3,250 people)?

The response was immediate. Grady Booch, who co-invented UML, called it evidence of Musk’s “profound incompetence” leading “an organization built around a software-intensive web-centric system.” The consensus verdict: you use LOC when you don’t understand what software is.

Fast-forward four years later…

OpenAI publishes a case study: three engineers, a repo of “on the order of a million lines of code… zero lines written by human hands,” 1,500 merged PRs in five months, presented as proof of concept; Stripe’s agents ship 1,300 PRs a week, zero human-written code, announced with the same energy; A widely-read engineering Substack leads with “Lessons From Building With AI Agents: 120k Lines of Code Later”; GitHub adds “lines of code changed with AI” as an official metric to the Copilot dashboard.

From brag posts to product decisions by the platform hosting most codebases, the count is the hook, the credential, the whole point. The profession that called bullshit on LOC as an engineering metric is now publishing the numbers. Congratulations, your LOC is back. What is it that we are masking? A double-standard, maybe?

Well, it might be true we’re using that metric again, but it’s different this time. It isn’t the same author, now is it?

If agents do the execution — the lines, the syntax, the implementation — the Drucker distinction just might hold cleanly enough. Knowledge work is task definition, not output; the knowledge worker decides what to build, the manual worker builds it. Agents are tools. Measuring a tool’s output by volume is what you do — machine throughput, widget production, PRs per week. The human orchestrating the swarm is the knowledge worker. The LOC is the machine’s readout. Nothing wrong with counting that.

I’d argue it’s a psychological phenomena that makes this feel coherent. Kahneman’s attribute substitution: when a hard question has no easy answer, the mind swaps in a tractable one automatically, without awareness. LOC is what’s there. In uncertain territory, a number restores a felt sense of agency. “120k lines” feels like knowing something.

Except, wait. Didn’t Karpathy say we’re already past code? Software 3.0: English is the programming language; the code is what the compiler emits. If that’s the paradigm, LOC isn’t a machine readout. It’s a count of compiler exhaust — the output of the layer you declared obsolete. The argument is: we’ve moved up the abstraction stack. The metric is: let’s celebrate what the abstraction discards.

Back then, Dijkstra’s word for the code that LOC incentivizes was “insipid.” Not incorrect. Not inefficient. Insipid — tasteless, flat, without character. Not a technical word, but an aesthetic one. And reviving LOC alongside not even noticing the double standard is exactly that - tasteless.

What happens now can be framed by borrowing from another industry. Fast fashion is producing so many clothes, so fast, that the sense of quality as a felt property quietly atrophies. The acceleration is the mechanism. Volume doesn’t just lower standards; it numbs the instrument you’d use to notice. With AI-generated code at scale it’s exactly the same. Not producing bad code, necessarily. Producing enough code, fast enough, that taste — the faculty Dijkstra was invoking when he said “insipid” — starts to dissolve.

In that respect the double standard doesn’t require cynicism. It doesn’t even require inattention. It just requires enough throughput that the instrument goes quiet — and then LOC starts to feel like a reasonable proxy, not because anyone decided it was, but because no one can quite feel the insipidity anymore.

The coding systems even named themselves for it: Notion’s head of AI called the vision a “software factory future”; Ona, formerly Gitpod, made it a manifesto: “From craft to mass production: Software as an industrial system.” Now it has a name: Dark Factories — borrowed from the lights-out manufacturing floors of the 1980s, where robots built robots and no human was on site. The naming is the theory. Walter Benjamin’s point was the same: mass reproduction doesn’t produce bad copies — it changes what the original means.

But maybe what’s underneath it all — and always was — is a question of relationship. How you see the other side of the work. Clark and Chalmers had a surprising claim: If you’d unhesitatingly rely on something, it’s reliably available, and it feeds directly back into your reasoning — it’s part of your mind. In their famous example, Otto — an Alzheimer’s patient who relies on a notebook in place of failing memory — IS using his notebook as memory in the relevant sense.

By this test, an agent you direct closely — one you interrogate, revise, push back against — isn’t a tool you hired. It’s your extended cognition. Your taste runs through it. The LOC-counting arrangement fails the test. You’re not extending into the agent; you’re delegating to it. The output feeds back as a number, not as thought. That’s not an extended mind. That’s a machine with a counter. And the difference matters: in one of those relationships, the taste’s aura is better preserved. And preserving it now, maybe more than ever, should be this community’s party line.