When I started at Parse.ly, Python was our language of choice. It was fast to write and easy to read. It fit our brains well and it’s juuuust performant enough for a realtime analytics system. The choice was explicit: prioritize developer time and happiness over machine time and cost.
ChatGPT and Github Copilot are upending that calculus. Over the next few years, developer unfriendly languages will become more appealing because LLMs will paper over the unpleasantness of actually writing code in them. The ergonomics and aesthetics of a language will take a backseat to performance, ease of deployment, and other concerns.
LLM-assisted coding is a sea change in software engineering, with Github claiming that nearly half of all new code is written by Copilot. There’s no reason to think that number won’t continue to grow, especially since most developers spend less than half their time coding.
The dynamic of LLM-assisted coding is different from writing code by hand. It’s an omniscient autocomplete that sometimes knows what you want before you do. AI-assisted coding is a superpower for developers, but one that fundamentally changes their relationship to the language they use. Deep knowledge of a language or framework is no longer necessary, or even desirable. Why spend years learning the internals of a language when an LLM is there to explain it for you? Instead, you get to focus on solving the problem you’re trying to solve because your copilot has you covered.
This extends to language choice in counterintuitive ways. A powerful copilot makes it easy to try out a new language, which sounds like it would be a boon for less popular languages. I think it will have the opposite effect. It’s easier to switch, but why would you? If you can write Rust as easily as Python, but get performance and memory safety, there’s no reason to use anything else. The human-centered ease of writing Python is irrelevant when humans aren’t writing it. Furthermore, popular languages will have more training data and therefore better LLM support. I think over the next few years developers will simply care less about languages. As one friend asked: have we seen the last new programming languages?
This may seem a bit premature. After all, ChatGPT happily churns out incorrect code all the time. But, it’s a question of when, not if, LLMs generate correct code every time. Once that’s true, LLMs will be writing and explaining most code. There will always be cases that push the edge of technology and can’t be written by machine, but that number will surely dwindle over time.
When most code is machine-generated, how much you like a language simply doesn’t matter. Other factors will be more important when choosing what to use. Performance, tooling, and knowledge of how to operate it at scale will all be more important than the language itself.
Given that, what does matter? LLMs are improving quickly, but some skills are harder to replace than others.
Product-minded thinking has always been a superpower and that’s not going to change. John Carmack made this point on Twitter. OpenAI may write all our code one day, but it’s still going to need someone to tell it what to write.
System design falls into this bucket, too. An LLM could design a generic distributed system, but large, complicated systems are designed to solve specific problems. Understanding a problem domain, and its constraints, will be hard to replicate. The same goes for UX, which needs a combination of domain expertise, solid design principles, and, simply, taste.
Debugging will likewise continue to be an area of human expertise for some time. It’s a combination of domain knowledge, realtime data ingestion, and often raw intuition. The real-world has a way of hitting all the corner cases in a piece of code. LLMs will, for a while, have a hard time ingesting the right data to do this automatically.
Note that these are all language-agnostic skills. Unless a language is limiting the kind of system you can design or the debugging tools at your disposal, the language itself won’t matter. Languages don’t matter anymore.
Oh, I’d also add writing secure C code to the list. That’s a superhuman feat for anyone. The day the machines are smart enough to do that, it’s time for humanity to throw in the towel.