Your Management Playbook Assumed Code Was Expensive

Every engineering management rule you inherited has a hidden assumption baked into it, and most of those assumptions were priced in an economy where a line of working code cost real money. That's the uncomfortable audit Karim Jedda, an engineering director, ran in an essay that hit the Hacker News front page this week — and the reason it resonated is that the data has been quietly agreeing with him for two years.

Jedda's discipline is worth copying: he commits to exactly one fact — the cost of producing plausible code has collapsed and isn't coming back — and treats everything downstream as a hypothesis to test against each rule's original assumption. Some rules ("directors shouldn't code," "shield the team from the business") were load-bearing only while code was expensive. Others, the ones about coordination and accountability, matter more than ever. That framing beats both the "nothing has changed" and "fire half the org" camps, because it gives you a procedure instead of a vibe.

The data says the bottleneck moved, not shrank

Three independent datasets back the essay's central mechanism — that cheap generation relocates cost rather than eliminating it.

DORA's research across 2024 and 2025 found AI adoption improves throughput while hurting software delivery stability. Google's researchers put it plainly: AI doesn't remove the effort of review and validation, it pushes that effort downstream into pipelines that weren't sized for the volume. Faster in, shakier out.

GitClear's analysis of over 200 million changed lines shows what that volume looks like in a repo: code blocks with five or more duplicated lines grew roughly eightfold during 2024, copy-pasted code overtook refactored code for the first time in their dataset, and churn — code revised within two weeks of landing — climbed from a pre-AI baseline around 3% to over 7%. That's the signature of plausible-but-unowned code shipping faster than anyone can consolidate it.

Then there's the perception gap. METR's randomized trial found experienced open-source maintainers completed tasks 19% slower with early-2025 AI tools — while estimating afterward that AI had sped them up 20%. The study's scope is narrow (16 developers, mature codebases, tools that have since improved), but the perception gap is the durable finding. If your staff engineers can be 39 points wrong about their own productivity, your sprint retro is not an instrument. Jedda's call for "honest instrumentation" isn't rhetorical; self-report is provably broken here.

We've collapsed the cost of code before — this time is different

The historical framing the essay gestures at deserves sharpening. Compilers, open source, and Stack Overflow each collapsed the cost of code too, and management adapted without existential drama. But those waves made already-solved problems cheap to reuse. A library you import carries someone's accumulated understanding; a Stack Overflow answer was vetted by the person who had the problem.

LLMs collapse the cost of drafting — producing text that looks like a solution without anyone having built what Peter Naur called the theory of the program: the mental model of why the code is shaped the way it is. Naur argued in 1985 that the program is that theory, and the text is just its shadow. Generation at scale produces shadows without theories, which is exactly why DORA sees instability and GitClear sees churn. The management problem of 2026 is provisioning theory-building in an org where the text is nearly free.

That's also why Fred Brooks survives the audit untouched. Communication overhead among humans didn't get cheaper — only output per human did. Adding headcount to a late project is still adding coordination cost; it just buys even less production than it used to.

What to actually change on Monday

The practical translation, for anyone running a team:

Kill volume metrics before they kill you. PR counts and velocity were always proxies, but they were correlated proxies when effort was scarce. Now the cheapest way to raise them is to generate more text, which Goodhart's law converts from measurement into sabotage. Measure outcomes — incident rates, time-to-restore, whether the thing shipped moved a business number.

Reprice review as the scarce resource. If generation is free and verification isn't, your senior engineers' review attention is the constraint, and you should schedule it like one. That means investing in machine-checkable correctness — types, contracts, property tests, invariants — so human review spends itself on the semantic question ("is this what the business needs?") that no checker shares. Jedda's warning that AI-checking-AI inherits the generator's blind spots is structurally sound, and it's the strongest argument in the piece.

Classify decisions before debating them. The reversible/irreversible split is Bezos's old two-way-door test, and it gets sharper when code is cheap: a reversible technical decision can now be tried for less than the meeting to discuss it would cost. The failure mode is misclassification — treating schema migrations and public API contracts as casually as feature-flagged experiments.

Treat the junior pipeline as a five-year liability you're accruing now. This is where the outside data is bleakest. Stanford's Digital Economy Lab, analyzing ADP payroll records, found employment for 22-to-25-year-old software developers down sharply since late 2022 while older cohorts grew. The judgment your seniors have was built on exactly the boilerplate and debugging that AI now absorbs. Jedda proposes structured review of generated code, deliberate unassisted exercises, and rotations through verification work — and honestly refuses to claim it's solved. He's right to refuse. Nobody has run the five-year experiment yet, and the orgs that stopped hiring juniors have quietly decided to let someone else run it for them.

Verdict

This is a genuine shift, not hype — the rare case where an opinion essay's mechanism is independently confirmed by DORA, GitClear, and METR from three different measurement angles. But the industry's actual response is backwards on both ends: still promoting on PR volume at the exact moment volume became free, and cutting the entry-level roles that manufacture the judgment verification now demands. The organizations that come out ahead won't be the ones that adopted AI fastest. They'll be the ones that repriced their org chart around what's still scarce: people who can be accountable for what the machine wrote.