We’ve spent decades optimizing programming languages for humans. Nicer syntax, higher-level abstractions, better type systems and better tooling, all in service of human authors. But something is shifting. Increasingly, we describe what we want and AI writes the code.
If that continues, there’s a question I can’t shake: if AI becomes the primary author of software, why would the next programming language still be designed for us?
The optimization target has changed
For most of the history of software development, the programmer has been human. That has shaped almost everything about the languages we’ve created. Readability matters because humans have to read the code. Syntax matters because humans have to write it. Abstractions matter because humans need to reason about increasingly complicated systems. AI doesn’t necessarily need those things in the same way.
It doesn’t get tired reading verbose code. It doesn’t need syntactic sugar to save a few keystrokes. It doesn’t forget an API because it hasn’t used it for six months. If AI eventually does most of the actual authoring, then it seems reasonable that the things we optimize a programming language for will change as well.
And if the optimization target changes, I think the language itself eventually changes with it.
We’ve moved the abstraction before
We’ve seen shifts like this before, although the comparison isn’t one-to-one.
Assembly wasn’t designed to be pleasant to read. It maps closely to the underlying hardware and gives the programmer very direct control over what the machine does. As software became more complex, languages like C gave us a higher level of abstraction while still staying relatively close to the machine. From there, we kept climbing.
The important part isn’t that an AI-native language would somehow be the new assembly. It probably wouldn’t look anything like assembly. The interesting parallel is that programming languages have always reflected what we’re trying to optimize for. Assembly was close to the CPU. Higher-level languages increasingly optimized for the humans writing software. So what happens when the primary author changes again?
A programming language for AI
I suspect the first truly AI-native programming language will look strange to us. Human readability might barely matter. Instead, the language could optimize for things such as unambiguous structure, deterministic behavior, rich metadata and the ability to compile efficiently to many different targets.
The same language, or representation, could potentially target a browser, a server, a mobile device or a compiled desktop application. Portability wouldn’t necessarily mean bringing the same runtime everywhere. It could mean giving the AI one representation from which it can reliably produce software for whatever environment is required.
There might still be humans who understand it, just as there are humans today who are perfectly comfortable reading assembly. But most developers wouldn’t need to. Because we wouldn’t be the ones writing it.
Intent and architecture
That doesn’t mean developers disappear. I think our role moves another level up the abstraction ladder.
We spend less time describing exactly how software should be built and more time describing what we want built. But intent is only one part of that. The other part is software architecture.
Someone still needs to reason about which services to use, where data should live, how systems communicate, which infrastructure makes sense, where the security boundaries are and which trade-offs we’re willing to make.
Those are interesting problems, and they’re much bigger than whether a particular function should be written in Go, Rust, Kotlin or Java. The implementation increasingly becomes the AI’s responsibility. Intent and architecture become ours.
I think someone will build this
If this line of thinking is correct, I’d be surprised if the frontier AI labs weren’t already exploring this space in some form. Their models are increasingly capable of being the primary authors of code, so a language or intermediate representation optimized specifically for AI generation and reasoning feels like a natural next step.
And if it doesn’t come from one of the frontier labs, I suspect one of the large technology companies will eventually arrive at the same conclusion.
We’ve spent decades optimizing programming languages for human developers. If AI becomes the primary author of software, I think it’s inevitable that sooner or later we’ll optimize the language for AI instead.
Today’s programming languages aren’t going to disappear overnight. There is far too much software, knowledge, tooling and infrastructure built around them. But perhaps Go, Rust, C++, Kotlin and Java eventually become less important as languages that humans actively write and more important as targets, runtimes or implementation details underneath another layer of abstraction. And maybe that next layer isn’t really designed for us at all.
So, what if the next programming language isn’t for us?