As we increasingly delegate the act of writing code to AI agents, a profound question emerges: Will traditional source code even exist in the future? To grapple with that, we must first understand what code really is. Unmesh Joshi, a seasoned software architect, argues that code serves two intertwined purposes: precise instructions for a machine and a conceptual model of the problem domain. This dual nature makes code far more than just syntax—it’s a tool for thought, a language for conversation with computers, and a bridge between human intent and machine execution. In this article, we’ll dive into the twin pillars of code, explore why vocabulary matters, see programming languages as thinking tools, consider the impact of large language models (LLMs), and finally ponder whether source code will vanish or transform.
1. Code as Machine Instructions
At its most basic level, code is a set of explicit instructions that tell a computer exactly what to do. Every line—from a simple variable assignment to a complex algorithm—is translated into binary operations that the CPU executes. This mechanical aspect is what makes code unforgiving: any ambiguity or error leads to crashes or unintended behavior. Joshi emphasizes that this “instruction to a machine” function is what gives code its power and its precision. Without this layer, we couldn’t build the software that runs our world. Yet, focusing only on this aspect misses half the picture. The machine doesn’t care about the elegance of the code; it only cares about the correct sequence of operations. Still, understanding this bedrock purpose is essential for any developer, because it grounds every abstraction in the physical reality of silicon and electrons.
2. Code as a Conceptual Model of the Problem Domain
Beyond telling the machine what to do, code also represents a conceptual model of the real-world problem being solved. When a programmer writes an e-commerce application, the code contains entities like Product, Order, and Customer—these are not part of the machine’s world but exist in the developer’s mind as representations of business logic. This is the “second purpose” Joshi highlights: code serves as a thinking tool that structures our understanding of a domain. The vocabulary we choose—class names, function names, module structures—shapes how we reason about the problem. Over time, the codebase becomes a living document of the team’s shared mental model. Changes to the code aren’t just technical tweaks; they reflect evolving insights about the domain. Without this conceptual layer, code would be an indecipherable stream of tokens, impossible to maintain or extend.
3. The Vital Role of Building a Vocabulary to Talk to the Machine
Programming languages are essentially vocabularies we construct to communicate with computers. But as Joshi explains, the words we choose matter enormously. A well-named variable like customerTotal carries meaning for human readers, while still being executable by the machine. This is where the two purposes of code intersect: the right vocabulary makes the machine instructions readable and the conceptual model clear. In the era of LLMs, this vocabulary becomes even more critical because AI models learn from the patterns in our code. If our code is messy and poorly named, the AI will replicate that mess. Conversely, clean, expressive code—rich with domain-specific terminology—helps LLMs generate better suggestions and maintain coherence. Building a good vocabulary is not just about readability; it’s about creating a bridge between human intention and machine execution that both parties—humans and AIs—can understand and extend.
4. Programming Languages as Thinking Tools
Code isn’t just a medium for instructing machines; it’s a powerful thinking tool that shapes how we approach problems. Different languages encourage different modes of thought. For example, declarative languages like SQL prompt us to think in terms of what we want, while imperative languages like C focus on how to achieve it. Joshi suggests that the act of programming is an exercise in cognitive modeling: we translate messy, ambiguous human needs into precise, logical structures. This transformation forces us to clarify our own thinking. When we write code, we are not only communicating with the machine but also with ourselves and our colleagues. The code becomes a scaffold for reasoning, allowing us to break down complex problems into manageable pieces. As we move toward a future where agents write much of the code, we must ensure that these thinking tools remain accessible so that we can understand, critique, and evolve the systems we create.
5. The Future of Code with LLMs and Agents
With the rise of large language models (LLMs) like GPT, an increasing portion of code is generated by AI agents rather than written by humans. This raises the question: will source code as we know it still exist? Joshi’s perspective offers a nuanced answer. Source code’s primary role as a conceptual model—a human-readable blueprint—will likely remain important even if the machine instructions are generated by AI. We will still need to define the problem domain, choose the vocabulary, and validate that the generated code aligns with the intended model. However, the nature of writing code may shift from typing every line to crafting prompts and curating outputs. The source code may become more like a high-level specification, with AI filling in the details. But as Joshi warns, we must not abandon the conceptual rigor that good code requires; otherwise, we risk building systems we cannot understand or trust.
Conclusion
Code is far more than a set of instructions for a machine. It is a dynamic, dual-purpose artifact that captures both the mechanical steps and the conceptual essence of a problem. As we delegate writing to AI agents, we must remember that the vocabulary we build and the thinking tools we create are what make code intelligible and maintainable. The future may look different—with less hand-typed source code—but the fundamental need for a clear conceptual model will persist. By understanding what code truly is, we can design a future where humans and AI collaborate to produce software that is both powerful and comprehensible.