Decoding the Future: What Is Code and Why It Matters

Before diving into questions about source code and its evolution, it's important to grasp what code really is. According to Unmesh Joshi, code serves two interconnected functions: it gives precise instructions to a machine, and it embodies a conceptual model of the problem we're trying to solve. This dual nature makes code a powerful thinking tool. As we increasingly delegate writing code to AI agents like large language models (LLMs), we must reconsider the role of source code. Will it vanish, or will it transform? The following questions explore these ideas.

What are the two distinct purposes of code?

Code has a dual identity. First, it is a set of instructions that a computer can execute. This is the machine-facing side, requiring precision and unambiguous syntax. Second, code acts as a conceptual model of the problem domain. It captures the relationships, rules, and logic of the real-world problem we're addressing. For example, a banking application's code not only tells the computer to transfer money but also models concepts like accounts, transactions, and balances. These two purposes are intertwined: the machine instructions implement the conceptual model, and the model gives meaning to the instructions. Understanding this duality helps us see why building a vocabulary is so crucial.

Why is it vital to build a vocabulary to talk to the machine?

To communicate effectively with a computer, we need a shared vocabulary. This vocabulary is built through programming languages, which provide keywords, syntax, and structures to express our ideas. Without a consistent vocabulary, the machine cannot interpret our intentions correctly. More importantly, this vocabulary shapes how we think about problems. When we define terms like “user,” “order,” or “payment,” we are encoding a mental model. This vocabulary evolves as we gain deeper understanding of the domain. In the age of LLMs, the vocabulary may shift from code to natural language prompts, but the principle remains: clear terms are essential for reliable machine interaction.

How are programming languages thinking tools?

Programming languages are not just tools for giving instructions; they are thinking tools that influence how we approach problems. Each language encourages a certain way of reasoning. For instance, object-oriented languages push us to model the world as objects with properties and behaviors, while functional languages lead us to think in terms of transformations and immutability. As Joshi points out, the act of writing code forces us to clarify our assumptions and break down complex ideas into manageable parts. This mental discipline helps programmers understand their domain more deeply. Even when using LLMs to generate code, we still need to think through the problem to frame it correctly.

Will source code disappear in the future with LLMs?

Given that we increasingly delegate code writing to LLMs, some speculate that traditional source code might vanish. However, Joshi argues that source code will likely persist, but its form and role may change. Currently, source code is both the instruction set and the conceptual model. LLMs can generate instructions directly, but they often lack the deep understanding of the problem domain that a human programmer brings. Source code serves as an external memory and a communication artifact among developers. Even if LLMs produce executable code faster, humans will still need to review, understand, and maintain the conceptual model. So code will remain, but perhaps as a higher-level abstraction or a hybrid of natural language and formal logic.

How does working with LLMs affect our understanding of code?

Interacting with LLMs shifts our focus from writing code to defining intent. Instead of typing every line, we describe what we want in natural language. This changes the skill set needed: we must become better at articulating requirements and verifying outputs. However, the dual purpose of code still applies. The conceptual model remains vital; we need to ensure the LLM has a correct understanding of the domain. This means we may need to refine prompts, provide examples, and maintain a clear vocabulary. LLMs can amplify our productivity, but they also require us to think more carefully about the models we embed in our requests. The future of programming may be more about conversation than code.

What is the role of source code as a communication medium?

Source code is not just for machines; it is also for people. Developers read code to understand how a system works, to find bugs, and to extend features. Code acts as a shared language among team members, documenting decisions and logic. When we rely on LLMs, this human-readable aspect becomes even more important. If code is generated automatically without clear structure or comments, it may become hard to maintain. Therefore, good code is still written with readability in mind—using meaningful names, consistent formatting, and comments where needed. The conceptual model embedded in code serves as a reference for future developers, including oneself.

How can we prepare for a future where LLMs write most code?

To thrive in an LLM-dominated future, we should focus on system design and domain modeling. Since LLMs can handle syntax and boilerplate, our value shifts to deciding what to build and why. We need to become experts in defining the conceptual model—the vocabulary, rules, and constraints of the problem. Additionally, we must develop skills in prompt engineering and evaluation. Learning to debug and test LLM-generated code will be crucial. Finally, we should continue to write and read source code to maintain a deep understanding. As Joshi implies, code as a thinking tool will never be obsolete; it will just be supplemented by intelligent agents.