Engineering management after the cost of code collapsed
When AI made code cheap to generate, half the old management rules broke—but the other half became more important, because cheap generation makes verification the constraint, not typing speed.
Read Original Summary used for search
TLDR
• The cost of plausible code collapsed, but most management practices haven't caught up—audit assumptions, not age: practices built on "code is expensive" are broken, practices built on "humans coordinate and verify" matter more
• Verification splits in two: mechanical checking (types, tests, lint) is collapsing in cost, but semantic verification (does this match business needs?) can't be automated because AI checking AI shares blind spots
• The junior pipeline is broken and nobody admits it—the practice that built senior judgment (fixing bugs, writing boilerplate) is now done by AI, consequences arrive in 3-5 years
• Management's information-routing work (summarizing, tracking) goes to zero value; what survives is judgment and ownership—the work someone has to sign
• In the agentic limit, orgs become "a short list of names attached to decisions"—headcount measures accountability capacity, not production capacity
In Detail
The core thesis: LLMs collapsed the cost of generating plausible code, but most engineering leaders are sorting practices by feel (modern vs. old) rather than by examining underlying assumptions. The correct approach is to audit what each practice actually rests on. If it assumes code is expensive to write, it's broken. If it assumes humans need to coordinate, build trust, or verify correctness, nothing changed—and some of these matter more now.
The most important framework is the verification split. Mechanical verification—anything machine-checkable like types, tests, contracts, lint rules—is collapsing in cost because agents can run the test loop faster than humans. But semantic verification (does this implement the actual business policy?) cannot be automated because AI checking AI shares training data, biases, and blind spots. Both fail in the same places. This creates three consequences: (1) unit cost of checking falls but total workload rises with volume, (2) how much of your correctness is machine-checkable becomes a strategic variable—teams with strong specs win, teams with weak specs get AI reviewing AI, and (3) the slowest part was never checking speed but accountability—someone has to sign and own the risk.
The junior pipeline is an unsolved problem everyone ignores. The practice that historically built senior judgment—fixing small bugs, writing boilerplate, getting stuck—is now absorbed by AI. The pipeline breaks on a 3-5 year delay, so you won't notice until it's too late. Anyone claiming to have solved this is selling something. For management work itself, information-routing functions (aggregating status, translating updates, forecasting schedules) are going to zero value. What survives is judgment and ownership—the work that can't be written down, can't be averaged, and can't be signed by anyone else. In the agentic limit, organizations become "a short list of names attached to a long list of decisions"—headcount stops measuring production capacity and starts measuring how much accountability you can afford.