1. The Ancient Argument
For millennia, human civilization has been built upon the shifting sands of interpretation. The Bible, the U.S. Constitution, international treaties, and great philosophical works share a frustrating commonality: they are static documents that spark eternal arguments. We pore over historical context, punctuation, translation, and the original intent of the author, yet two brilliant scholars can look at the exact same sentence and reach incompatible conclusions.
This isn’t a bug in natural language; it’s a feature.
Natural language developed for social cohesion, negotiation, storytelling, persuasion, and keeping peace within tribes. It is “slippery” by design, allowing for the nuance, poetry, implication, and strategic ambiguity necessary for human cooperation.
However, this leaves us with a fundamental problem: we have always struggled to define exactly what words mean when there is no objective way to prove an interpretation.
For most of human history, words could describe reality, argue about reality, or attempt to change someone’s perception of reality.
Then we invented words that could run.
2. The “Run” Button: When Words Become Behavior
Programming languages represent a radical departure from almost every form of text that preceded them. Code isn’t just an idea communicated to another person. It is an instruction designed to produce behavior.
In the world of natural language, you can spend hours explaining your “intent.” In the world of code, the machine is indifferent to what you meant to say.
The computer doesn’t care. Run it. Something happens. Now you have evidence.
The “Run” button transforms language into evidence. It moves us away from explaining the “why” and forces us to confront the “is.”
Did the program work?
Did it crash?
Did it produce the expected result?
Did it produce something completely unexpected?
This is the moment language stops being only a medium of persuasion and becomes a medium of action.
3. A Third Species of Truth
We may be witnessing an evolutionary pressure on language itself, leading to the emergence of what could be called a third species of truth.
Historically, human communication has relied heavily on two broad forms.
Descriptive Truth: Describing how the world is. “The Earth revolves around the Sun.”
Normative Truth: Describing how the world should be. “Murder should be illegal.” “People should honor their agreements.”
Now we have something different: Executable Truth, the language of performance.
Executable Truth doesn’t merely describe a goal. It attempts to cause the goal directly.
That makes it fundamentally different from ordinary language because it sharply reduces the usefulness of the “that’s not what I meant” defense. The machine doesn’t evaluate your intentions. It evaluates your instructions.
If the code does something you didn’t expect, your intention may explain the mistake, but it doesn’t change what happened.
When a script runs, one particular argument ends.
The computer has shown you what those instructions actually do.
4. Code as the Ultimate Scientific Method
Programming is effectively the scientific method applied to language.
It follows a brutal logical loop:
Hypothesis: You believe these specific instructions will produce a specific result.
Experiment: You run the code against defined conditions and tests.
Result: The resulting behavior either supports your logic or forces you to revise it.
In law, philosophy, politics, or theology, there is no universal “RUN” button that reveals which interpretation of a text is objectively correct. People can disagree indefinitely because there is often no executable test of the author’s meaning.
Programming changes the relationship.
Debugging is a forced admission that reality gets the final vote.
It is the process of locating the exact distance between what you believed you wrote and what you actually wrote. The computer isn’t insulting you. It isn’t taking the other side. It isn’t questioning your motives.
It simply executes the instructions.
Programming therefore creates something unusual: a language that can argue with reality instead of merely arguing with other people.
5. Nature’s Original Programming
Humans didn’t invent the concept of executable instructions. We may have simply discovered another way to imitate something nature has been doing for billions of years.
DNA contains biological instructions that function, in some respects, remarkably like code. Those instructions produce proteins, structures, behaviors, and eventually organisms that must survive in a physical environment.
Evolution doesn’t hold a committee meeting to interpret a genetic mutation or debate what a particular trait was “supposed” to accomplish.
The biological machinery operates. The organism encounters its environment. Reality provides feedback.
Sometimes the result works.
Sometimes it doesn’t.
Nature doesn’t care what the instructions intended.
Programming introduces a similar feedback mechanism into human-created language. We write instructions, execute them, observe the consequences, and modify the instructions.
Write. Run. Fail. Debug. Run again.
That loop may be one of the closest things human language has ever developed to natural selection.
6. When Ambiguity Becomes a Liability
For most of civilization, ambiguity wasn’t necessarily a weakness. Sometimes it was extremely useful.
Diplomats use ambiguity to allow opposing governments to accept the same agreement without publicly surrendering their positions. Politicians use it to build coalitions. Religious and philosophical texts survive for centuries partly because generations can continue interpreting them. Ordinary people use ambiguity every day to navigate relationships without turning every disagreement into a mathematical proof.
Human society needs some linguistic flexibility.
Computers don’t.
That creates a growing collision between two different communication systems.
Humans frequently communicate through implication.
Machines require specification.
Humans tolerate exceptions.
Machines require rules for the exceptions.
Humans say, “You know what I mean.”
The machine effectively answers, “No. Tell me exactly what you mean.”
As software becomes responsible for more financial, commercial, industrial, and administrative decisions, ambiguity can move from being socially useful to operationally dangerous.
The question changes from “What did we intend?” to “What exactly did we instruct the system to do?”
7. The Collision: Smart Contracts and AI Agents
The tension between interpreted and executable language is becoming increasingly visible in digital finance, smart contracts, automation, and artificial intelligence.
A traditional contract is written for humans. If something goes wrong, lawyers, arbitrators, regulators, or judges may have to determine what the parties intended.
A smart contract introduces another possibility: some parts of the agreement can execute automatically when predetermined conditions are satisfied.
That is a profound shift.
The agreement is no longer merely describing what should happen. Part of the agreement can cause something to happen.
Artificial intelligence adds another layer.
AI systems operate through natural language remarkably well, but they can also generate executable code. That creates a strange bridge between the two worlds.
An AI can propose an explanation in ordinary language and sound convincing.
But when it produces code, we can run it.
Now the reasoning encounters falsification.
The proposed solution either survives the test or it doesn’t.
Concepts such as Ricardian contracts push the idea even further by attempting to connect human-readable legal agreements with machine-readable execution.
Natural language allows:
“That’s not what I meant.”
Executable language responds:
“That’s what you wrote.”
8. The Future of Human Coordination
Executable Truth doesn’t mean programming languages will replace natural language.
They shouldn’t.
Natural language handles things computers struggle to reduce to strict instructions: emotion, mercy, negotiation, context, symbolism, humor, forgiveness, love, and the countless exceptions that make human beings human.
But executable language gives civilization something different.
It gives words consequences that can sometimes be demonstrated immediately.
That changes the nature of an argument.
For thousands of years, humans have fought over what words mean. We created scholars, courts, councils, philosophers, theologians, lawyers, and entire political systems to manage the ambiguity.
Now, for the first time on a massive scale, we are creating languages where meaning can sometimes be demonstrated through execution.
Not argued.
Not interpreted.
Run.
That may represent more than a technological innovation. It may represent a new stage in the relationship between language and reality.
We are moving from an era dominated by perpetual interpretation toward one in which at least some meaning can be demonstrated through behavior.
And that leaves us with one of the most interesting philosophical questions of the digital age:
What would human civilization look like if more of our arguments could be tested instead of interpreted?
