Programming Languages were for us, Not for the Machines

Setting the scene

Elon Musk told an xAI all-hands earlier this year that artificial intelligence (AI) will soon skip source code altogether and generate optimised binary straight from a plain-language prompt, possibly by the end of 2026. Most of the engineering community laughed. Compilers already translate code in milliseconds, they are deterministic, and Grace Hopper solved this problem in 1952. The laughter is fair on the timeline. It misses the point on the question.

Programming languages were never for computers. Machines have only ever executed ones and zeroes. Every language since Hopper's first compiler exists for one reason: so humans can read, write and check what the machine is about to do. Human-readable code is a courtesy extended to us, at real cost in abstraction and translation. AI does not need the courtesy.

The direction of travel

The ends of the chain are already occupied. At the natural-language end, Andrej Karpathy declared back in 2023 that the hottest new programming language is English. At the machine end, Google DeepMind's AlphaDev worked directly in assembly instructions, not a high-level language, and discovered sorting algorithms up to 70% faster for short sequences. Those routines now sit inside LLVM's standard C++ library, used by millions of developers who will never read them. Meta has since trained a Large Language Model (LLM) Compiler on compiler intermediate representation and assembly. The human-readable layer in the middle is only load-bearing while humans are doing the reading.

And the reading is already straining. Checksum's State of AI Code 2026, a survey of 105 engineering leaders published last week, found that 78% trust AI-generated code more than they did a year ago. Yet 61% shipped a production incident originating in AI-written code in the past 90 days, and 74% rolled back AI code after failures their unit tests missed. Trust is rising while the verification layer leaks.

What aviation already learned

When airliners moved to fly-by-wire, starting with the Airbus A320 in 1988, pilots lost their mechanical connection to the control surfaces. Nobody inspects the cables anymore; there are none. Safety did not disappear with the linkage. It moved into the certification regime: the test envelope, the redundancy requirements, the failure modes rehearsed before the aircraft ever carried a passenger. Commercial aviation's safety record kept improving through that transition, because the assurance system that replaced legibility was funded, owned and taken seriously.

Is that the path for software and computer languages? When the artefact becomes opaque, assurance does not vanish, it relocates. The question is whether it relocates into something you have deliberately built, or into a gap.

The three stages

• Stage 1: AI writes, humans review everything. Where most organisations sit today, and where the Checksum numbers say the model is already leaking.

• Stage 2: AI writes, humans review by exception. Verification systems gate every release; senior engineers audit the gates, not the lines.

• Stage 3: Machine-native artefacts. Code written for the machine, in whatever representation suits it. Humans specify what must be true, and the verification stack is the entire control surface.

You do not need to believe Musk's timeline to act on the direction. Every stage shifts value from reading code to trusting tests.

How should we prepare?

Treat the verification stack as the strategic asset it is becoming. Give it a named, accountable owner, the way you name an owner for the customer database. Fund it as infrastructure rather than as a line inside each delivery team. Measure it on the metric that matters: how often a failure reaches production without a test catching it, the number that already sits at 74% rollback rates in AI-heavy teams. And extend it beyond functional correctness into performance, security and ethical gates, because those are the clauses of the contract you will still own when the code itself is no longer written for you.

The takeaway

The source code was never really the asset. It was the ledger we could read. As AI moves software toward machine-native forms, the durable human artefact is the definition of what must be true, and the systems that prove it. If that is where your control is heading, it deserves structure, an owner, a budget and a clear strategy towards this evolution.