Simon Willison wrote up his 1, 3, and 6 year AI predictions from his chat with the lovely Oxide crew. This is always a fun thing to ponder as you start a new year, especially since 2025 feels like such a futuristic number.
I found myself reflecting on this myself, and landing on a provocative thought. What if the most popular development language 6 years from now isn’t a back and forth between Python and JavaScript, or a “new” language such as Rust, but is something much more radical: English.
When I say “English”, I am using it somewhat as a short hand for natural language, so it can actually include many other languages such as Spanish and Mandarin.
This seems somewhat outlandish, right?
Maybe not so crazy given Karpathy having said this awhile back?
So, how could it come to pass?
- Computers can now understand natural language (and other inputs that humans do, such as images and sound)
- Computers can write code based on that understanding (including filling in the gaps)
- Humans already use English for large parts of the development process (documentation, comments, issues, PR conversations, group chat conversations, etc etc)
Let’s dive in.
Computers are increasingly grokking us
When you look at the history of computing, we see a continuous rise in abstraction in how we are able to talk to computers. We started speaking at a very low level with punch cards, machine code, and assembly language. Only a few people had the capability and understanding on how to get computers to do things, and those things were fairly limited (yet still amazing!).
Over time, we taught the computers abilities that would allow humans to increasingly share intent at higher levels of abstractions. Why have the humans track the memory in the computer if we can make the computers do that work?
Part of the story is in building the abstractions, and the technology breakthroughs such as garbage collectors that are fast enough, or LLMs that can write code. Intertwined with this trend is the dramatic shift in raw numbers, as illustrated by Tailscale CEO Avery Pennarun in his piece on living in the numbers. The rate of change is hard to fathom. We are used to CPUs that get faster, and GPUs that can multiply matrixes increasingly quickly, and more memory, and larger faster disk, but OMG when you see the actual magnitude of the change… how computation is 200,000x faster than 20 years ago etc… it can sink in that we can expect so much more from our systems.
It’s not that we can have fewer instances handle a few more HTTP requests. Our computers can grok what we say, can see images and video, and can hear audio. How much improvement will there be in 6 years across all of these vectors? Today is the worst we have it, with repeated changes coming. Mind blowing.
The reason that we see so many applications pop up with a chat side bar is a signal that we are building bridges between the computers and the humans in natural language ways.
With development, we see this in almost all of the tools that we use. Coding assistants started with helpful auto complete, but we want to communicate deeply with the Borg connected pair programmers that we now have available 24/7. Chop chop.
Computers can write code
I mean, humans have always written code. Since the beginning of computing, we’ve created systems that translate human-written instructions from one format into another that computers can understand.
But now, we’ve evolved beyond that. We can use plain English as input and get not just code, but various other digital assets as output.
Writing code isn’t just about mastering syntax. It’s about understanding platform capabilities and technological ecosystems. LLMs possess a vast knowledge base of this information, and with deep context awareness, they can comprehend what truly matters – your code and all its dependencies.
Humans already use English
When you think about your development projects, you realize that a large amount of your time isn’t writing for loops, it’s understanding the requirements of your business and mapping them to the technology that needs to drive it.
You write requirements. You have conversations with your team in Linear and Slack and …. You have code comments. You chat with your coding assistant. We are already using English.
The difference in 6 years though, is that we will be able to switch to a spec-centric vs. code-centric way of development.
Guypo goes over this in this talk: What is AI Native Development:
Don’t think of this as a one time moment where all of a sudden all that every developer does is write specs.
It can, and will, happen gradually. This has always been the way with development.
Python rocks up and has the ability to link to C libraries and thus has access to the evolved corpus of well tested libraries that have been worked on for decades. The same can happen here. The wrapping will occur, and the lower level can evolve as makes sense. The great feature of this new approach is that the generation from English to implementation can always be re-run with the latest gains.
Compare the two paths:
Current: you open chat with your favorite coding assistant and go back and forth to get some code for certain functionality. When you are happy with it, it ends up in your codebase. You lose the context of the chat and the English intent, and you now have a base, based on the state of the art of that moment. You are left with the compiled output, so to speak.
Future: your English is the source, and as your computer systems improve, they can be regenerating new and improved implementations. It behooves you to invest in testing and validation in this world, but this is something that is actually really needed any way… we just sometimes get away without doing it.
Once we work out how to get good at this level of abstraction, more amazing things can happen. Because LLMs can understand many languages, both nature and programming, we are not truly multi-lingual. The flexibility that comes with this can be transformational, but it is also very different. Being able to fill in the gaps isn’t the same as inheritance and composition. When do we need to be more explicit vs. when is that more than makes sense to say? How do we prompt humans for more information so they can elaborate? Do we sometimes want to use pseudocode to explain something?
Popular doesn’t mean, solely!
Notice that there are items that are not being said in this prediction?
“You don’t mean that everyone will just be writing English only, right?”
No. Most popular doesn’t mean only. There will be room for traditional code. It’s also important to remember that when we use the term “developer” we are doing a lot of work. There is a massive spectrum of people doing very different things, with very different skill sets.
There are engineers still doing very low level work, and everyone on top of those layers gets to benefit without having to do so (e.g. on top of an operating system, or using standard libraries, etc). As we wire up new platform capabilities, that wiring may be done via platform APIs are not in English.
So, while English will play a role for everyone, I think that it will best suit cases higher up the stack, with the app developers. It will be important to still understand the platforms you are building on top of, and programming languages. But this may become less important over time.
“Why did you say development language not programming language”
This is purposefully broader to represent the usage beyond the programming aspects of software development is all.
“Does this mean you think there won’t be the need for developers?”
The opposite. I think our appetite for software is insatiable, and I’m excited about how this can democratize development, and how the flexibility can allow the personalization of computing experiences for users. If there are fewer curly braces, that doesn’t mean that there isn’t any more development going on!
We have a lot to work on to make this all happen, and I will now set a calendar entry in Jan 2031 to re-read this and see how far off I am.
What are your predictions for how software development will change in 6 years?