Writing
The Medium Was Never the Work
Brett Wheeler
Writing software has always meant writing code: precise symbols, handed to a machine that turns them into the running thing. That made the text feel like the work — but the text was never the work. It was always a translation of intent, and the machines now learning to read intent directly are exposing a shape that was there all along. It's also why, all of a sudden, nobody can agree on what to call the job.
For seventy years the word held. Fortran, Lisp, C, Python — variations on a single move: write precise symbols, hand them to a compiler, watch the symbols become the running thing. The artifact and the text were the same object. We called it code, from codex — a system of rules written down — and the word was honest, because the system was the writing.
What's shifting now isn't the purpose of programming. It's where the real work sits. The text is no longer the thing. Intent is. Intent, specified well enough, produces the text — sometimes with a person in the loop, increasingly without one. The translation layer between what you meant and what runs, the layer we used to call our craft, is becoming machinery.
So the interesting move here isn't AI replaces coders. The interesting move is the realization that code was always intermediate. Knuth defined programming, decades ago, as "the art of telling another human what one wants the computer to do." He said another human — not the compiler. The compiler was a footnote. The real work was specification: telling a peer what you want, with the executable bytes falling out as a side effect of that conversation. We rarely had to be honest about this, because the only specifier on offer was a programmer typing into an editor, and the only reader on offer was a parser — the thing that reads the code. So the shape stayed hidden. But the shape was specification all along, and the new readers — language models, agentic systems, whatever comes after them — are exposing a shape that was already there.
Here's why the shift feels disorienting: we mistook the medium for the work. The medium is leaving. The work was never the medium.
Vocabulary is scrambling to catch up. None of the candidates have won yet, and watching them compete tells you what each one quietly believes about the work.
Prompting crested early and is already dated. The unit is too small — prompts are single-shot, and sustained work is not a sentence.
Prompt engineering had its moment and has receded. Most people who do it well no longer call it that.
Context engineering is sharper, championed recently by Simon Willison and a handful of others. It captures the real preparation: system prompts, examples, retrieved documents, memory, tools. But it describes the table-setting more than the dinner.
Vibe coding, Karpathy's coinage from early 2025, is deliberately informal. It names a mode, not a category, and will probably survive as slang for the freewheeling end of the practice without ever becoming the formal term.
AI engineering and agentic engineering are both jockeying for the role-title slot. One of them probably wins inside five years.
Specifying is the cleanest of them. The spec is the new primary artifact, and the verb that produces specs is the new center of the work. Its problem is cultural, not technical: spec still carries the bureaucratic weight of an older way of building software, the kind programmer culture has spent decades shedding. The word is right; the associations are wrong.
And then there's intent — the wildcard. No one has planted a flag on it yet, but it's quietly threaded through how the new agent tools talk about themselves. Give the agent intent, not instructions has become a design principle in places that never compared notes. If a tool with enough pull stakes a claim on the word, intent-driven development could end up the dominant frame — the way version control, for a whole generation, simply became git.
So here's the likeliest outcome. Over the next five to ten years, engineering alone — used as both noun and verb — becomes the umbrella, with AI or agentic bolted on in front when the specifics matter. And coding narrows to mean the literal typing-out of text inside the larger practice, the way typing narrowed once writing stopped being a typist's job.
There's a quieter observation underneath all of this, and it's the one that matters most.
Descartes anchored selfhood in thought: cogito ergo sum, I think therefore I am. The structure of that move — find the irreducible thing, then build outward from it — has shaped a lot of how the West frames work, including how we framed programming. The irreducible thing was the text. Everything else was arrangement around the text.
But thinking, by itself, doesn't produce much. Choice does. Intent does. The act of deciding what should be — and then arranging the world to match — is older than any tool we've ever used to do it. Code was one such tool. A long-lived one. Not the last.
What changes when the translation layer thins out isn't the work. The work is what it always was: notice what is, specify what should be, let the rest follow. The Daoists had a word for the let the rest follow part: wu-wei, non-forcing. And it's strange, a little funny even, that the most modern-feeling shift in software keeps rhyming with a 2,500-year-old idea — working with the grain instead of against it. The grain was always intent. We just spent seventy years polishing the chisel.
None of this is a forecast about jobs, or a manifesto, or a take. It's an observation, and observations are cheap. The reason to say it out loud is that the words we use for our work quietly shape what we believe the work is. When the words start to drift, the work has usually already moved — and the people who notice the drift early tend to spend the next decade doing different things than the people who don't.