Source Code Isn't Going Anywhere
Generative AI is by far the most discussed topic of 2025, and at the beginning of 2026 it’s still what everyone is talking about. This post is not meant to teach you how to use it for building software or how to make money out of it. I’m not an expert on any of these topics. I’m a software engineer who, like many of us, has incorporated GenAI tools (like Claude Code or Codex) into my daily workflow.
One thing can be said for sure: it helps me do my job, and I hope it will only get better with time. That said, it has some hard limitations and I want to talk about one of them. Something that I believe is already acknowledged by the engineers but keeps coming up in discussions, especially with people outside engineering. The idea that, even if we are not there yet today, the source code will eventually be replaced with prompts. That one day, talking to your LLM will be the primary way of building software and that the source code will become an insignificant artifact of the development pipeline.
That is not possible, and in this article I will quickly explain why. I also understand that these claims may come across as suspicious. After all, I spent most of my life learning programming languages and how to use them. It’s not about job security, though. It’s about the fundamental limitation of the LLM-based generative AI that we should all be aware of.
You can’t replace source code with a prompt
The key argument against replacing source code with prompts is that natural language used to communicate with LLMs is not precise. There are other problems with LLMs in their current form, such as the fact that they are not free. Even if we take open-source models into account, you would still need a powerful machine to run them. Compared to programming, where the learning material is available for free online and it doesn’t have any special system requirements, generative AI is an exclusive technology. But all that aside, the argument about lack of precision should already be enough to close the discussion.
The reason we have programming languages is to allow engineers to write instructions in human-readable code. The code that humans write, however, is not what machines can “read”. To function, machines need what we call machine code – a sequence of zeros and ones that is unreadable to humans. We couldn’t write any complex application in the pure machine code if we tried, it’s virtually impossible. So we invented programming languages and tooling for converting the source code into machine code.
Getting to where we are today with modern programming languages (like Python, Rust, Go, TypeScript, etc.) was a slow process. It took us decades, and as a result we got a lot of programming languages to choose from. Some of the older ones are still actively used today, while others are forgotten. That said, the underlying idea behind every single one of them is the same. Have humans read and write code and let the programming language tooling handle the rest, so that it can run on the machine. There are two artifacts only: source code and machine code.[1]
Programming languages can be read and understood by humans, but it doesn’t mean it comes naturally. Every software engineer had to spend time learning a programming language they wished to use, and some languages take years to master. It may seem like a serious limitation but it is there for a good reason. The key feature of the programming languages is that they are strict and they leave no room for interpretation. As a consequence, a machine will do whatever you tell it to. The result may be beautiful, dumb, or plain irresponsible. Tell it to drive a car into a wall, and it will do so, and this is not a flaw. The effective one-to-one correspondence between code and execution is the foundation on which every programming language is built.
Large Language Models change that picture drastically. Before the advent of GenAI, turning an idea into working software required someone who could write code. Now, a machine can generate code from a plain-English description. This is remarkable because it introduces a third stage: an LLM prompt that is turned into source code. This is exciting, also given the fact that modern AI tools are capable of doing much more than just generating code. They can scan thousands of lines of code in seconds, spot patterns, find inconsistencies, and provide the analysis back in a language that anyone can understand. This is something that couldn’t be easily done before, so the productivity gains for software engineers will be unlike anything the industry has seen in a long time.
With all that said, natural language is not precise enough to describe executable instructions reliably. An inherent property of every human natural language is that it’s open to interpretation. It works for communication between humans, but it can be an obstacle in areas where we want no ambiguity. It’s the reason mathematicians devoted centuries to developing rigorous formal notation. In that sense, formalism is an achievement of civilization. It is the core mechanism that enables precision. Programming languages are grounded in the mathematical formalism and inherit this property. When you understand the source code, you know for sure how the machine will behave. The same can’t be said about the natural language.
You shouldn’t surrender source code, even if you could
Let us also remember the other aspect of software engineering: maintenance. The true feat is not writing code that works, but doing it in a way that is easy to adapt to the ever-changing business conditions.
Imagine that source code is an unimportant middle stage between prompt and machine code, that no one has to read or understand. Wouldn’t that mean we will lose our ability to build maintainable systems? Investigating every bug or making any change to the existing codebase would require involving LLMs to understand and modify it. It’s an unsettling perspective, but I’m sure it would be great news for companies whose business is selling tokens.
So no, source code is not going anywhere. It will be read, and modified by humans. Understanding source code keeps us in control. Surrendering it for convenience may seem like a good idea until you see the invoice.
In reality it’s much more complicated than that. Compilers and interpreters will use various optimization techniques that may produce many more intermediate-stage artifacts. In normal circumstances, software engineers are not required to read or modify them, and the last stage is always the same: the machine code. ↩︎