Introduction: The Evolving Nature of Source Code
As artificial intelligence agents increasingly take over the task of writing code, a fundamental question arises: will human-readable source code remain relevant? To address this, we must first understand what code truly is. According to software engineer and author Unmesh Joshi, code serves two distinct yet intertwined purposes: it provides precise instructions to a machine and simultaneously acts as a conceptual model of the problem domain. This duality explains why programming languages are not just technical tools but also powerful thinking aids—and why their role may shift but not disappear as we collaborate with large language models (LLMs).
Code as Machine Instructions: Building a Vocabulary to Talk to the Machine
At its most basic level, code is a set of commands that tell a computer what to do. Every programming language, from low-level assembly to high-level Python, provides a vocabulary and syntax for expressing these commands. Without code, we would have to communicate with machines through binary or hardware-specific signals—a tedious and error-prone process. By creating a human-readable yet machine-executable language, code bridges the gap between human intent and computer execution.
Joshi emphasizes that this instruction-based role is what enables software to be deterministic and repeatable. When we write code, we are crafting a sequence of operations that a computer can follow exactly. This precision is critical for everything from banking transactions to flight control systems. However, as LLMs become more adept at generating code from natural language prompts, the act of writing instructions manually may recede. Yet the instructions themselves—the code—must remain accurate and verifiable, regardless of who or what writes them.
Programming Languages as Thinking Tools
Beyond mere instructions, programming languages shape how we think about problems. They provide abstractions that help us organize complexity. For example, object-oriented languages like Java or C++ encourage us to model real-world entities as objects with properties and behaviors. Functional languages like Haskell push us to think in terms of pure functions and immutable data. These paradigms influence the solutions we design.
Joshi argues that this cognitive dimension is what makes code more than a set of steps. When we write code, we are simultaneously building a mental model of the domain we are working in—whether it's e-commerce, healthcare, or game development. The code itself becomes a living document of that model. This dual role explains why experienced developers often say that writing code helps them understand the problem better.
Code as a Conceptual Model: The Problem Domain Perspective
The second purpose of code is to serve as a conceptual model of the problem domain. Instead of just telling the machine what to do, the code describes the structure and behavior of the system in terms that are meaningful to humans. For instance, in a library management system, you might have classes like Book, Patron, and Loan. The relationships and operations among these classes map directly to real-world concepts.
This modeling aspect is critical for communication among team members, for maintenance, and for reasoning about the system's correctness. If the code accurately reflects the domain, changes to business rules can be traced and implemented more safely. Joshi notes that this is why domain-driven design (DDD) places such emphasis on a shared, ubiquitous language. Code is the ultimate repository of that language.
How LLMs Change the Landscape
With the rise of LLMs like GPT-4 and specialized coding agents, we now delegate much of the instruction-writing to AI. This raises the question: if machines generate the instructions, do we still need human-readable source code? Joshi's framework suggests that the conceptual model becomes even more important. LLMs can generate code from specifications, but those specifications must be precise and grounded in a clear domain model. The generated code, in turn, must be traceable to that model.
Furthermore, code remains the most precise description of the conceptual model. Natural language is ambiguous; code is not. Even if an LLM writes the code, a human must verify that the generated instructions align with the intended domain logic. This means that the need for source code—as a readable, inspectable artifact—will persist, but its role may shift from being primarily written by humans to being primarily reviewed by humans.
Conclusion: Source Code's Enduring Role
Unmesh Joshi's analysis reveals that code is not merely a technical artifact but a dual-purpose communication tool: it talks to the machine and models the world. As AI agents take over more coding tasks, we may write fewer lines from scratch, but we will still need code to serve as the authoritative representation of both instructions and conceptual understanding. The future may see new programming paradigms that blend natural language and formal logic, but the essence of code—its role as a bridge between human thought and machine action—will remain. Understanding this duality helps us prepare for a world where we collaborate with LLMs rather than being replaced by them.