Introduction
As artificial intelligence agents increasingly write code on our behalf, a pressing question emerges: Will traditional source code even exist in the future? To grapple with this, we must first understand what code truly is. According to thought leader Unmesh Joshi, code serves two interlinked purposes: it gives precise instructions to a machine and it represents a conceptual model of the problem domain. This guide will walk you through five steps to grasp these dual roles, build a rich vocabulary for human-machine communication, and prepare for a world where humans and large language models (LLMs) collaborate on code.
What You Need
- Basic familiarity with any programming language (e.g., Python, JavaScript) — optional but helpful
- A curious mindset and willingness to think abstractly
- Access to a code editor or an online coding environment for experimentation
- Patience to practice reframing code as both execution and explanation
Step-by-Step Guide
Step 1: Recognize the Dual Nature of Code
Start by looking at any piece of code — even a simple function like add(a, b) { return a + b; }. On the surface, it tells the computer to perform addition. But it also models an abstract concept: addition of two numbers. This is the first insight: code is simultaneously a set of machine instructions and a conceptual model. To internalize this, ask yourself: What problem does this code solve? How does it represent that problem in terms of variables, functions, and data? Write down both the machine-level behavior and the human-level meaning for every snippet you encounter. This dual-awareness is the foundation for everything that follows.
Step 2: Build a Vocabulary to Talk to the Machine
Machines speak only binary, but programming languages act as translators. Your next task is to deliberately cultivate a rich vocabulary of constructs — variables, loops, conditionals, functions, objects — each of which is a tool for expressing both instructions and concepts. For example, a while loop instructs the CPU to repeat an operation, but it also models repetitive processes in the real world (e.g., processing items on a conveyor belt). Practice by taking a real-world scenario (like a library checkout system) and describing it first in plain English, then translating that description into code while consciously noting how each code element maps to the concept. This builds the bridge between human thought and machine execution.
Step 3: Treat Programming Languages as Thinking Tools
Now go deeper: understand that each programming language shapes how you think about problems. A language like Haskell emphasizes pure functions and immutability, guiding you to model solutions as mathematical transformations. In contrast, JavaScript allows mutable state and event-driven patterns, encouraging you to think in terms of changing states and user interactions. Spend time comparing how the same algorithm (e.g., sorting a list) is expressed in different languages. Notice how the conceptual model changes — from imperative step-by-step to declarative description. This activity reveals that code is not just a way to talk to the machine but a lens through which you view and structure reality.
Step 4: Analyze How LLMs Are Changing Code Creation
LLMs like GPT-4 and Claude can generate code from natural language prompts. This step is about observing the shift: when an LLM writes code, it usually outputs instructions that work, but the underlying conceptual model may be shallow or inconsistent. Compare a hand-written function with an LLM-generated equivalent for a complex task (e.g., validating an email address). Ask: Which one better represents the domain? Which one is easier to maintain? You’ll likely find that human-crafted code often carries richer abstraction because the programmer intimately understands the problem. This insight is critical for the final step — designing how humans and AI should collaborate.
Step 5: Apply This Understanding to Future Human-AI Workflows
Now you’re ready to envision the future of code. Given the dual nature, the best approach is to let LLMs handle the instruction layer (writing syntactically correct, efficient code) while humans focus on the conceptual model layer (defining the problem, creating abstractions, ensuring the code faithfully represents the domain). In practice, you can: (a) describe your conceptual model in natural language or pseudocode, (b) ask an LLM to generate the instructions, (c) review the output for both correctness and conceptual alignment, and (d) refine the model iteratively. This hybrid workflow preserves the human’s role as the designer of meaning, even as the machine executes details. As you practice, document how the source code evolves — will we still need a human-readable file, or will the LLM’s latent understanding suffice? Usually, a persistent source representation remains valuable for debugging and evolution.
Tips for Success
- Practice daily by taking a small piece of code and writing two descriptions: one of what it tells the machine, another of what concept it models.
- Embrace multiple programming paradigms (imperative, functional, object-oriented) to enrich your mental toolbox.
- Stay critical of AI-generated code: always verify that the conceptual model behind the output is sound.
- Think about the future: as you write code today, imagine how an LLM might interpret your abstractions — and try to make them clearer for both humans and machines.
- Join communities discussing the philosophy of code and AI — such discussions deepen your own understanding.
By following these steps, you will not only understand what code is — you’ll be equipped to thrive in an era where humans and LLMs co-create software, keeping the essential human role of conceptual modeling alive.