Essential Until It Wasn't

What we call programming today is not the same activity it was two years ago. The daily work, the skills that matter, the texture of the craft — all changed. And yet people talk about it as if “programming” names a fixed thing that AI tools either threaten or enhance. But “programming” has never rested on solid ground.

This is an excellent short read from Kyle Mathews on the whole “Coding with AI Agents isn’t really coding” thing.

Nobody mourns the loss of opcode memorization now. Nobody argues anymore that “real programmers” allocate registers by hand. Those fights happened — older engineers did complain that high-level languages were making people soft — but the fights are over. The boundary moved, and everyone adjusted.

The same pattern repeated with API memorization. Before StackOverflow and intelligent IDEs, a programmer’s value partially resided in knowing obscure API details from memory. Then between searchable answers and autocomplete that surfaces signatures on demand, that knowledge became instantly accessible. The boundary moved again. What was once essential became accidental.

Now AI is doing the same thing by moving the boundary up past implementation-level reasoning. Writing code character-by-character, debugging by manually tracing state, holding syntax in your head — all the things that felt like the craft’s irreducible core — are becoming accidental complexity. The work still happens. Humans just stop doing it.

Every time this boundary moves, some of us say the same thing: “They’re not real programmers.”

Assembly programmers said it about FORTRAN programmers. C programmers said it about Java programmers. And now it’s being said about people who write software by directing AI.

This complaint is not evidence that the craft is dying. It’s the sound the fault makes when it shifts — essential becoming accidental, solid ground suddenly twenty feet from where it was.

These complaints point to a true loss. But what’s being lost is a particular adaptation, not the craft itself. Their specific mastery — the patience, the precision, the tolerance for tedious debugging — was an adaptation to engaging with complexity that was essential at the time and has since become accidental. The mastery was real. Its relevance was temporary.

I especially love this part, because I’ve been echoing this exact sentiment for years.

Peter Naur, in his 1985 paper “Programming as Theory Building,” argued that the essence of programming was never the code. The code is an artifact. The essence is the theory — the programmer’s mental model of what the system does, why it does it that way, and how the pieces relate. The code expresses the theory, but the theory lives in the programmer’s head.