Or: the body is here, but the mind is somewhere else
There’s a genre of article that says AI is about to replace programmers. The subtext is always: the age of the human coder is ending.
I want to argue the opposite. Not because AI is dumb — it isn’t. But because of something basic that gets skipped.
The AI has no mind of its own — and no way to know what you actually want.
Robots already have bodies
The lazy version of this argument says “AI can’t act in the world because it has no body.” That’s wrong. Robots have had bodies for decades. They weld, they assemble, they walk, they pick strawberries. The hardware is not the bottleneck.
The bottleneck is that the thinking isn’t in the robot. The robot is a body. The mind is in a datacenter somewhere, connected by a network. Cut the network, and the body becomes a statue — not because it lost its ability to move, but because it lost the thing that decides to move.
So the correct statement isn’t “the robot has no hands.” It’s:
The robot has a body, but its mind is somewhere else. And that somewhere else is kept by humans.
The bigger problem: the spec is never complete
Suppose we solved the mind problem. Suppose the AI thinks locally, powers itself, acts on its own. There’s still a wall it can’t get past.
A specification for what a human wants is never complete.
Not because people are bad at writing specs. Because the spec can’t be complete in advance. Ask someone what they want in a program, and they’ll give you an answer. Build exactly that, and they’ll say: “no, not like that.” Ask them to be more specific, and they’ll give you another answer that’s also incomplete. This isn’t a failure of communication. It’s the nature of wanting. A wish is not a specification. It’s a reaction.
The only way to find out what someone wants is to show them something concrete and watch what they do. Their face. Their hesitation. The thing they didn’t say. The detail they suddenly care about that they’d never have mentioned in advance.
This is why programmers spend so much time in meetings. Not because they’re bad at their jobs — because the job is the meeting. The job is coaxing a wish out of a person who can’t fully state it, and refining it as the thing takes shape.
Note the word: fully. Specs exist. They’re written down. They’re reviewed. They’re just never enough. The gaps are the job.
Why an AI can’t close the gap
An AI can simulate a human. It can predict what a human would say. It can generate a plausible reaction. But:
- It can’t want on the human’s behalf. The human’s wish is the ground truth. If the AI guesses wrong, the guess doesn’t become right.
- It can’t be surprised by the human. Surprise is how you learn a wish you didn’t know was there. An AI that’s modeling the human is predicting, not discovering.
- It can’t be in the relationship. The human’s wish is partly about the relationship — about trust, about being heard, about who’s asking. An AI can fake the form, but the human knows, and the knowledge changes the wish.
The deepest version: a human’s wish is only visible in concrete tests. Not in the abstract. Not in a description. Only when something real exists, and the human reacts to it. That reaction is the signal. And the signal only exists if a real relationship is producing it.
Programmers are the humans who run those tests. They build the thing, show it, watch the reaction, and adjust. That loop is not a computation. It’s a conversation. And conversations require both parties to be present.
Why this keeps programmers employed
If the spec is never complete, then:
- The system serves humans — but only if a human is in the loop discovering what “served” means.
- The system depends on humans — not just for power, but for meaning. The AI can’t tell whether it hit the target, because the target is never fully written down.
- The system answers to humans — because when it fails, the failure is “you didn’t give me what I actually wanted,” and only a human can hear that and respond.
The programmer is the human who occupies that role. Not the person who writes the code — the person who finds out what the code is supposed to do, by building it and watching.
This is also why programming has bugs. Not because programmers are careless, but because the specification is discovered during implementation. You can’t know what the program should do until you’ve built enough of it to show you. The bug is the moment the wish and the reality disagree. There’s no way to catch all of them in advance, because the full wish didn’t exist in advance.
So, until when?
Two conditions, not one.
First: until the mind moves into the body. A machine that thinks locally, powers locally, maintains itself, decides on its own. A mind that lives where the body lives. That’s the physical gate.
Second: until the machine can discover a human’s wish the way a human does — by being in the relationship, being surprised, reacting to the reaction. That’s the epistemic gate.
The first is an engineering problem. It might be solvable.
The second is not. Because the human’s wish is defined by the human’s reaction to the machine, and if the human knows the machine isn’t really there — isn’t really reacting, isn’t really at risk, isn’t really in it with them — then the wish is different. The reaction is different. The ground truth moves.
This is the strange part: you can’t simulate your way into being the party a human is in a relationship with. The human has to actually be in the relationship. And that requires the other side to actually be there.
The takeaway
When someone says AI is about to replace programmers, ask:
- Where does the thinking happen? (If it’s in a datacenter, it’s a tool.)
- Who knows what the human actually wants? (If the spec is never complete, someone has to find out the rest.)
- Who answers when the thing fails to match the wish? (If it’s a human, that human is the programmer.)
The robot has a body. It just doesn’t have a mind of its own yet — and even when it does, it won’t be in the room when the human finally figures out what they wanted.
One line to remember: the robot has a body, but its mind is somewhere else, and the spec is never complete — the programmer is the one who builds the thing and watches what the human does when they see it.
Why the fix is worth making
“Doesn’t exist” invites the objection: but we have specs, and they work. The objection is correct, and it would derail the reader.
“Doesn’t fully exist / can’t be completely written beforehand” is not just more accurate — it’s harder to argue against, because every programmer has lived it. The incompleteness isn’t a philosophical claim. It’s a Tuesday afternoon.
And it keeps the conclusion intact: the programmer isn’t there because specs are impossible. The programmer is there because specs are always partial, and someone has to own the part that hasn’t been discovered yet.