In the public imagination, a “genius programmer” is often portrayed as someone who sees the world in code, solving problems at a level few can comprehend. These figures are usually fast, precise, and fluent in complex symbols. But this image, while romantic, conceals something important. Much of what is called intelligence in programming is closer to performance than philosophy. It’s about mastering a particular set of rules, solving problems quickly within a bounded system, and gaining status within a specific culture. It is impressive, but it is not necessarily reflective.
Think of it like a Rubik’s cube competition. Solving the cube in record time is a feat of memory, technique, and pattern recognition. But it does not demand that one reflect on the nature of color, symmetry, or spatial logic. In the same way, much of modern programming is about producing outputs, optimizing systems, and manipulating symbols. It rewards fluency within constraints, not necessarily awareness of those constraints themselves.
The arrival of AI only makes this clearer. With large language models now capable of generating code from plain English descriptions, the value of manual coding skill is changing. Suddenly, expressing intent becomes more important than knowing syntax. The power lies not in symbol manipulation, but in clarity of thought. And that shift raises deeper questions about what intelligence really is, and who possesses it.
Programming as a Symbolic Game
At its core, programming is a language game. It consists of a set of symbols governed by a rulebook. You combine those symbols in valid ways to produce behavior. In this sense, programming is not fundamentally different from spoken or written language. Both rely on a shared understanding of form and function. The difference is that programming languages are designed deliberately, often with a focus on precision and predictability, while natural languages evolve over time, shaped by culture, history, and use.
Each programming language creates its own symbolic universe. It defines what counts as a valid expression, how values are assigned, how flow is managed, and what kinds of errors are tolerated. Learning a language is not just about understanding its syntax, but about absorbing its logic and internalizing its expectations. Much like entering a guild, joining a programming community often involves adopting its rituals, idioms, and heroes.
These symbolic systems are useful, but they also have boundaries. They encourage a particular style of thinking. A C programmer thinks about memory. A Java programmer thinks about structure. A JavaScript programmer thinks about flexibility. These are not just tools; they are worldviews. And as with any worldview, there is a risk that familiarity becomes ideology. That which cannot be expressed in the language becomes invisible or dismissed as irrelevant.
Comparing the Worldviews of Code
Every programming language carries within it an implicit philosophy. Consider Python. It emphasizes readability, simplicity, and human-centric design. Its syntax is clean and forgiving. There is a saying in the Python community: “Code is read more often than it is written.” The values here are collaboration, transparency, and ease of entry. Python invites a kind of clarity that feels closer to conversation than command.
Now contrast that with C. It is small, fast, and close to the machine. Writing in C means thinking about memory addresses, pointer arithmetic, and low-level performance. It rewards precision but punishes abstraction. Mistakes can crash systems or open security holes. This is a language for those who value control and accept risk.
Java, meanwhile, offers the opposite promise. Its verbosity and strict typing are often criticized, but they also serve a purpose: stability and predictability in large systems. Java is the language of enterprises. It wants to minimize surprises. It expects its users to be architects rather than improvisers.
Then there is JavaScript, the wild child of the web. It evolved without a clear direction and absorbed quirks from multiple paradigms. It is flexible to a fault, forgiving of sloppiness, and endlessly adaptable. It reflects the chaos and creativity of the internet itself.
Haskell and other functional languages represent a different path. They lean toward mathematical purity. They treat functions as values, discourage side effects, and aim for declarative expression. These languages often feel more like proofs than procedures. They attract those who seek elegance and abstraction over practicality.
What ties all these together is that each language not only solves problems but also teaches its users how to think. And yet, none of them are neutral. Each imposes a way of seeing, a way of building, and a way of knowing.
Wittgenstein, Chomsky, and Peirce
Ludwig Wittgenstein, in his later philosophy, described language not as a mirror of reality but as a collection of games. Each game has its own rules, and meaning arises from participation, not from static definitions. This applies perfectly to programming languages. Their symbols only mean something within the game. Outside that context, they are just glyphs.
Wittgenstein reminds us that fluency in a language does not imply philosophical insight. You can follow the rules perfectly without ever reflecting on why those rules exist, or what they exclude. Most programmers, like speakers of a natural language, operate within their language rather than above it.
Noam Chomsky, meanwhile, sought to uncover the deep structure beneath all languages. He believed that humans are born with an innate grammar; a set of cognitive structures that make language possible. In programming, this idea manifests as a belief in the universality of logic and structure. Languages may differ, but the underlying logic is shared. This idea helped inspire formal language theory and compiler design.
Yet Chomsky’s view often left out the messier aspects of meaning: ambiguity, irony, metaphor, tone. These are essential to natural language but difficult to capture in formal grammars. Programming languages, too, lack these layers. They are precise but shallow. They can execute but not interpret.
Charles Sanders Peirce adds a crucial third perspective. He defined meaning as a triadic relationship: a sign, an object, and an interpretant; the mental concept formed in the mind of the perceiver. In this framework, symbols do not mean anything on their own. They require someone to interpret them.
This is where programming, and now AI, runs into its limits. Machines can process signs. They can manipulate syntax. But they do not form interpretants. There is no subjectivity. No felt experience. No internal world. Just outputs.
AI and the Collapse of Symbolic Prestige
As artificial intelligence systems become more capable, they begin to erode the prestige of symbolic expertise. You no longer need to memorize the intricacies of a language to build a program. You can describe what you want in English, or other natural languages, and a model can generate working code. The power shifts from syntax mastery to conceptual clarity.
This change exposes something long hidden: that much of programming was ritual performance. It was not about thought, but about translation. Not about ideas, but about expressing those ideas in an accepted dialect.
In this light, the figure of the “genius programmer” starts to look less like a philosopher and more like a high-speed typist trained in obscure syntax. That skill still has value, but it is no longer exclusive. The symbolic walls are crumbling.
Yet this shift brings its own risks. As AI produces more fluent outputs, we may begin to confuse fluency with understanding. We may accept simulations of thought as substitutes for thought itself. We may forget that syntax is not meaning, and that words, whether written by a human or a model, only come alive in interpretation.
The Question of Interpretation
Can AI truly interpret anything? The answer depends on what we mean by interpretation. If we mean producing plausible responses, then yes. AI can do that. But if we mean forming a conscious relation to a symbol, experiencing its meaning from within, then no.
John Searle’s thought experiment, the Chinese Room, illustrates this well. A person inside a room can follow rules to respond to Chinese questions without knowing a word of Chinese. The responses may be perfect, but they are empty of understanding. The person does not interpret; they execute.
This is what AI does. It processes signs without being affected by them. It produces meaning-shaped output without any internal experience. There is no self to whom the symbols mean anything. There is no care, no attention, no context beyond correlation.
Some argue that if the performance is good enough, the difference does not matter. If the poem moves you, does it matter if it was written by a machine that feels nothing? If the code works, does it matter who wrote it?
But others say yes, it does matter. Because interpretation is relational. It involves presence, attention, and a kind of vulnerability. To interpret is not just to understand, but to be changed by what is understood.
A Post-Symbolic Ethic
We now live in a world where symbols can be generated indefinitely by machines that do not understand them. This abundance brings new challenges. In such a world, our task is not to produce more language, but to preserve meaning.
That means cultivating the human skills that cannot be automated: reflection, judgment, listening, and care. It means knowing when words are alive and when they are merely fluent. It means resisting the temptation to treat simulation as substance.
Real intelligence is not fast output. It is thoughtful response. It is the ability to pause, to interpret, to choose. It is not measured by how many tokens are processed, but by how well meaning is held, examined, and made durable.
As machines take over the game of symbols, we are left with something more important: the question of what symbols are for. Not how they are formed, but why they matter. And in that question, the soul returns.
Image by Adam Małycha
Tom’s Blog 