By Pavan Kumar T V · 21 June 2026

Series: start with Part 1 on why English is too loose, then Part 2 on error correction. This is Part 3.

Two posts arguing about whether English can be the programming language, and a sharp reader finally asked the question hiding under the question.

Forget which language. Why do we need a language at all?

If a model can take what you want and produce a running result, the whole tower in the middle starts to look like a toll booth on a road that no longer needs one. Python, C, assembly, even English. Strip them all out. The cleanest version of the dream, the one Elon keeps gesturing at, is English in and binary out, straight onto the machine, with nothing legible in between. And that dream is really a bet on one answer to the deeper question: that a language was always a crutch for human weakness, and a machine smart enough to skip it finally throws the crutch away.

I think the answer is the exact opposite. And the reason is sitting in plain sight, in a fact the dream never stops to notice.

The machine never needed a language in the first place.

The machine never needed a language

A CPU does not parse Python. It does not want C. It has never read a word of English. It pushes voltages through gates. Every language in the entire stack, Python and C and assembly and even the instruction set the chip advertises to the world, lives above the silicon, and every one of them was put there for reasons that sit on our side of the glass.

So "a smart enough AI doesn't need the intermediate languages" is true, and trivial, and completely beside the point. The machine never needed them either. We did. The tower of languages was never a translation the hardware demanded of us. It was a translation we demanded of the hardware, turning what it actually does into something we could read, agree on, check, remember, and trust.

Which means the question "why do we need a language" has a hidden word in it, and the word is we. It was never the machine. So before you can ask whether a machine still needs a language, you have to ask what the language was doing for the humans the whole time, because that is the part a smarter machine doesn't touch.

So what is a language actually for

Strip a language down to its jobs and you get a short list, and the striking thing about the list is that not one item on it is about the machine's ability to run anything.

agree with other people      a shared medium minds can meet in
agree with your later self    an artifact that outlives the intent
check that it is right        intent and result, laid side by side
catch your own slips          redundancy that makes an error visible
build big things from small   named pieces you can reuse and trust

Every one of those needs lives between parties. Between you and a teammate. Between you and the version of you who opens the file in March. Between you and a result you have to rely on without re-deriving it from scratch. A language is the precipitate of those relationships. It is what intent has to harden into the moment more than one person, or more than one moment in time, depends on it.

The verification job is the one my last two posts kept circling, so look at it closely. Of the layers in the tower, only one lets you compare what you meant against what you built, by eye, before anything runs:

English   readable, ambiguous       you can read it, you can't trust it
binary    unreadable, unambiguous    you can trust it, you can't read it
code      readable, unambiguous      the only form that is both

That middle rung is not a convenience. It is the single place in the stack where precision and legibility live together, which is the only place the question "how will I know it's right" has ever had an answer. Delete it and you keep one property or the other, never both, and the question goes quiet for the worst possible reason.

Which of these does a smarter machine actually remove

Be fair to the dream. Run the test honestly. Of all the jobs a language does, how many does raw model intelligence dissolve?

Exactly one. "I need a language the machine can execute, because it can't run my intent directly." A capable enough model genuinely kills that reason. It can take the intent and produce the running thing with no hand-written C in between. Concede it completely, because it's true and it's the whole of what the dream actually delivers.

Now look at what is left standing. Agreement between people. Agreement across time. Verification. Error correction. Composition. Not one of those is about whether the machine can execute your wish. Every one of them is about whether you can trust what came out. A smarter generator removes the machine's need for a language and removes none of ours.

That is the entire sleight of hand. The dream takes "the machine no longer needs the translation," which is true, and sells it to you as "we no longer need the language," which simply does not follow. Different party. Different need. The translation was for the machine and it's going away. The language was for us, and it isn't.

The proof already shipped, and it points the wrong way

This stops being philosophy the moment you notice it already happened, at the assembly level, in code you are probably running right now.

In 2023, DeepMind's AlphaDev used reinforcement learning to discover new sorting routines written directly in assembly, up to 70% faster on short sequences, and they were merged into LLVM's libc++: the first change to the C++ standard library's sort in over a decade, and the first ever to come from an AI. A machine wrote machine-level code better than the humans who'd been at it for forty years. If anything was going to prove we can drop the language and trust the bits, this was it.

Watch what we actually did. We did not take the assembly on faith. We kept it as inspectable assembly a human could read. We pinned it to a precise, checkable spec, namely does it sort and is it faster. We made it reproducible. And humans independently vetted it before a single device ran it. The smartest code generator we have produced a full language artifact anyway, not because AlphaDev needed one, but because we needed to agree on it, check it, and trust it before it went into a library a billion machines lean on.

The single best evidence that we no longer need a language is the single clearest proof that we still do. When the result mattered, a language grew back around it, every property intact.

Everywhere you look, it grows back

The same thing keeps happening anywhere a result has to be relied on.

Neural compilation is real: Meta's LLM Compiler trained on 546 billion tokens of IR and assembly. Then you read the numbers, 77% of an autotuner's potential, 45% disassembly round-trip, 14% exact match, and you notice it works on inspectable intermediate representations inside the normal toolchain, because that is the only form anyone can check.

You might say my objection leans on non-determinism, and that's now fixable. Fair. Thinking Machines Lab showed in 2025 that LLM non-determinism is a batch-kernel artifact you can pin down to bit-perfect reproducibility. But reproducible is not verifiable. Same bits every time makes the output consistent, not correct, and a reproducibly wrong binary is just wrong on a schedule.

Even verifying a binary without its source, which people genuinely do with symbolic execution, works by lifting the bits back into a structured, readable logical form and checking them against a formal spec a human has to write. The language comes back as the verification artifact, and the spec is source code wearing a coat. You cannot escape it even when you try to verify your way around it.

And the inspectable layer is supposedly already a fiction, because nobody reads their 1,500 node_modules packages. True, until the chalk and axios supply-chain attacks hit, when the malicious versions were caught, diffed, traced, and pulled, because the source was there to read after the fact. Unread in practice still means readable when it bites.

Here is the part that should settle it. The two faces of the slogan are Jensen Huang, who said there's a new programming language and it's called English, and Andrej Karpathy, who coined vibe coding and built a working app for his kid in plain English. And what does vibe coding emit? Readable source code, run through the ordinary compiler. The flagship demo for "we don't need the language" produces a language you can open, run, diff, and fix. Nobody's real, shipped demonstration is English to binary. Every single one is English to code, because the moment the result has to be trusted, the language is not optional. It is what trust is made of.

When you genuinely don't need one

I'm not going to fence the whole idea off, because there is real ground it owns, and naming it sharpens everything above.

You need a language exactly when a result has to be relied on by a second party or a later moment. Remove both and the need evaporates. A throwaway script you run once and delete. A one-shot answer you read and discard. A generated image you glance at and either keep or don't. There's no one to agree with, nothing to check against, nothing to maintain, no future self to warn. English in, result out, never look at the middle, and that is exactly the right call, because there was never a relationship for a language to serve.

So the line was never AI versus human, and it was never English versus code. It is disposable versus depended-on. Anything anyone has to trust grows a language around itself, and anything truly disposable sheds it. The dream is a perfect description of the disposable half of the world and a catastrophic one for the half we have to live with, and the slogan blurs the two on purpose, because the disposable half is where the demos are filmed.

So, why do we even need a language

Not for the machine. The machine never cared, and a smarter one cares even less.

We need it for each other. For the teammate who has to change it next quarter. For the version of you reading the file in March with no memory of June. For the one moment it breaks at 3am and someone has to ask the only question that ever mattered, from the very first post: how will I know.

The machine will happily skip the language. It always could. We can't, and not because we're slow or sentimental, but because a language is the only place where agreement and verification and memory have ever been able to live, and those needs do not shrink as the model grows. They were never the cost of talking to computers. They are the cost of trusting what computers did.

English in, binary out, doesn't remove that cost. It removes the only place the cost could ever have been paid, and then hands you the bill anyway, the first time more than one of us has to depend on the answer.