We were never paid to type
Coding agents ended the puzzle half of programming. If the puzzles were what you loved, the loss is real. Clients were never buying the puzzles — they were buying the working system.
Agents write most of the code now, and it holds up. Hand one a stack trace and it points at the fault. Ask it for speed and it comes back twice as fast. The refactor you avoided for years finishes before lunch.
A lot of programmers are quietly grieving this, and the grief is not silly.
The puzzle was the job
For forty years the work ran on a strange scarcity. Computers could do absurd things, but only for people patient enough to give them exact instructions. Writing those instructions was a puzzle, and the puzzle paid. The harder it got, the higher the rate. Even the easy ones paid well, because most people could not do them at all.
That scarcity bought more than money. It bought timelines, deference, and the right to declare what was possible. And if you liked puzzles, and most of us got into this because we liked puzzles, you were being paid well to do the thing you would have done for free.
Two reasons people wrote code
The grief splits cleanly. Some programmers loved the puzzles themselves; the finished program was the receipt. Others loved working systems; each puzzle was a toll paid on the way to one.
If you were the first kind, the machines took the hobby and the leverage in one move, and no argument about productivity will soften that. If you were the second kind, you just received the largest tooling upgrade in the history of the field. Both are true at once, which is why the arguments about this go nowhere.
What the client was buying
Nobody outside the field ever bought the puzzle. A business pays for the shipment landing, the ledger closing, the customer serving themselves at 2 a.m. It cannot tell elegant code from dull code, and it should never have to. The typing was a cost that we, unusually, enjoyed paying.
That is why the work survives the loss of the typing. What a client buys now is what they were always buying: someone who can tell the working thing from the convincing one, who chooses what gets built, and who answers when it breaks at the worst possible time. Judgment, taste, and a name to hold responsible. The machine produces code and none of the responsibility.
The typing was never the product. The working system was, and it still needs someone who can tell the difference between done and almost.
Working on something this applies to? Tell us about it — thirty minutes, no pitch.