The Last Handwritten Program

Somewhere in the last couple of years, a programmer wrote the last economically significant line of code with no machine in the loop. Nobody noticed. Nothing broke. The industry simply crossed from humans-writing-software to humans-supervising-software-that-writes-software, and it happened mid-sprint, on a Tuesday.

The popular story says this is the end of programming. The popular story is half right, and the half it gets wrong is the important half.

What actually died

Syntax died. The thirty-year tyranny of semicolons, build configs, and boilerplate — the part of programming that was always translation rather than thought — is now machine work. A developer today can produce in an afternoon what a team shipped in a quarter, and the trend line has no visible ceiling.

But look closely at what the machine consumed: the typing. Not the deciding. Every system still begins with a human who must know — precisely, unsentimentally — what should exist, what trade-offs are acceptable, and what failure costs. Specification, it turns out, was always the hard part. We just couldn't see it under all the typing.

The verification asymmetry

Here's the structural fact that will define the next decade of software: generating code is now cheap; trusting code is still expensive. A model can produce ten thousand lines before lunch. Deciding those lines are safe to run against your customers' money is a different act entirely — and it doesn't scale with the same curve.

So the profession isn't disappearing; it's migrating into the gap between generation and trust. The engineer of this era reads more than she writes. She designs tests as policy, reviews diffs the way an editor reads proofs, and treats every agent like a brilliant junior with no memory of yesterday's standup. The pull request has quietly become the most important unit of management in the modern firm.

Programming becomes editorial

This is the reframe we run Agenticality on: software development is now an editorial discipline. Agents are the writers — tireless, fast, occasionally and confidently wrong. Humans are the editors — accountable, opinionated, ruthless about what ships. The codebase is the publication, and its quality reflects the editor's taste, not the writers' output.

The uncomfortable corollary: most of what the industry measures — velocity, lines, story points — measures the writers. Almost nothing measures the editors. The companies that figure out how to find, grow, and reward editorial judgment in engineering will compound; the ones still hiring for typing speed are optimising a solved problem.

The last handwritten program deserved a small ceremony. What replaces it deserves more respect than it's getting: not the end of a craft, but the moment a craft finally shed its clerical work and became, fully, a matter of judgment.