Greg Urbano

Posted on May 15

The Final Boss of Code Is the Future of Vibe Coding

#ai #malbolge #programming #vibecoding

A respectful response to everyone who thinks AI-assisted programming is just laziness with extra steps.

There is a programming language so hostile to human cognition that its own creator never wrote a working program in it.

Not a prototype. Not a proof-of-concept. Not even Hello World.

The man who designed it, sat down to use it, and gave up.

That language is Malbolge. It was created in 1998 as an act of deliberate cruelty. It was named after the eighth circle of Hell in Dante's Inferno. Its first working program wasn't written by a human at all — it was generated by a beam-search algorithm two years after release, because no human could figure it out.

And it is the most honest programming language ever made.

Because Malbolge didn't break the rules of programming. It just refused to pretend those rules were real.

The Language That Breaks the Premise

Most programming languages make one foundational assumption: that humans should be able to reason about programs directly.

Malbolge rejects this completely.

It runs on a ternary (base-3) virtual machine with exactly 59,049 memory locations. Its core operation — the crazy operation, or crz — is a tritwise function that is non-commutative, non-associative, and follows no algebraic intuition. It was not designed. It was discovered, like an archaeological artifact from a civilization that hated us.

Every time an instruction executes, it self-modifies — encrypted through a 94-character lookup table — so it won't do the same thing twice. The code rewrites itself while running. Programs don't loop; they decay into output.

A Hello World in Malbolge looks like this:

('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=<M:9wv6WsU2T|nm-,jcL(I&%$#"
`CB]V?Tx<uVtT`Rpo3NlF.Jh++FdbCBA@?]!~|4XzyTT43Qsqq(Lnmkj"Fhg${z@>

You don't read that. You witness it.

And for two full years after the language was released, nobody — not the community, not expert programmers, not Ben Olmstead himself — could produce a single working program.

The Moment That Changes Everything

In 2000, Andrew Cooke broke the silence.

Not by learning the language. Not by studying the spec until mastery arrived. He wrote a beam-search algorithm in Lisp that explored the space of possible Malbolge programs until it found one that output "Hello, world."

A program wrote a program. Because no human could.

This is the fact that reframes everything: the very first Malbolge program was machine-generated. Not AI-assisted. Not autocompleted. Fully algorithmic generation, because the alternative — direct human authorship — was not a viable option.

Malbolge was the first post-human programming language. The workflow it invented in 2000 was:

describe intent
unleash machine
validate output
accept what you don't fully understand

That no longer sounds like a workaround. That sounds like a Tuesday.

Your Stack Is Already a Horror Story

Critics of AI-assisted coding love to say: "If you don't understand the code, you shouldn't ship it."

At first glance, that sounds responsible.

But hidden inside it is a historical fantasy — the idea that programmers have ever fully understood the systems they deployed.

That stopped being true decades ago. Modern software engineering already depends on what you could call managed incomprehension. No single engineer fully understands browser engines, distributed orchestration systems, GPU kernels, cryptographic implementations, neural network internals, or the dependency graph of a typical production Node app.

This isn't incompetence. It's specialization. The entire history of software is the story of humans building abstractions larger than individual cognition can contain.

That's why we rely so heavily on testing, observability, fuzzing, benchmarking, simulation, and formal verification. Experienced engineers don't operate on total certainty. They operate on constrained trust and empirical validation.

The workflow has never truly been: "I understand every line completely."

The workflow has always been: "I understand enough, and I can validate the rest."

Malbolge simply makes this reality impossible to ignore.

Why AI Is the Right Tool, Not a Crutch

Here's what happens when a human tries to write Malbolge by hand:

Open editor.
Attempt to reason about the crazy operation lookup table.
Run. Crash.
Try to mentally trace self-modifying ternary state transitions.
Lose spiritual cohesion.
Give up.

Here's what happens when AI writes Malbolge:

Describe the desired behavior.
AI generates candidates using patterns from known working programs.
Run them. Validate output.
Accept the one that works.

Neither the human nor the AI "understands" Malbolge in the classical sense. The difference is that the AI can explore the search space millions of times faster, without the cognitive collapse that hits humans around step three.

AI doesn't "cheat" at Malbolge. It uses the only viable method — the same method Andrew Cooke used in 2000, scaled up. Malbolge's entire documented history confirms this:

1998: Olmstead releases Malbolge. Never writes a working program himself.
2000: First Hello World generated via beam search in Lisp. Not written. Generated.
2004: Lou Scheffer publishes a cryptanalysis and produces a working cat program. Relies entirely on automated search techniques and analytical tools, not hand-coding.
2005: Hisashi Iizawa produces the first 99 Bottles of Beer — with loops and conditionals — seven years after the language's creation.
2021: Kamila Szewczyk writes a functional Lisp interpreter in Malbolge Unshackled. It weighs over 350MB. She also wrote a book explaining it. Even she built programs to generate programs.

Every major breakthrough in Malbolge history was achieved through automation, tooling, and machine-assisted search. AI-assisted coding is not a departure from that tradition. It is the current chapter of it.

Addressing the Critics Directly

"You can't explain it, so you didn't really write it."

Ben Olmstead reportedly cannot explain a working Malbolge program either. Kamila Szewczyk wrote 350MB of Malbolge and an entire book to accompany it — the book exists precisely because the code alone is inexplicable. In this language, understanding and authorship are already decoupled. That's a feature, not a bug.

"Vibe coders can't debug."

In Malbolge, everyone debugs via tooling. Scheffer's 2007 cryptanalysis exists specifically because nobody debugs Malbolge by reading it line by line. Experts and beginners use the same method: run it, observe behavior, iterate. Behavioral debugging is not a shortcut. It is the gold standard for systems that exceed direct tractability.

"AI-generated code is unverifiable."

The Turing completeness of Malbolge wasn't proven by formal proof first — it was demonstrated by running a Lisp interpreter in it and seeing it work. Behavioral verification is how all complex systems get validated. Source readability is a proxy for confidence, not the thing itself.

"You're not actually learning anything."

Partially true, partially reversed. When AI explains trit arithmetic and register state transitions while you iterate on output, you learn more contextually than you would staring at a spec cold. The pedagogy is different, not absent.

"Fine for toys, not real codebases."

This is the objection with the most teeth, and it deserves respect. Nobody should use Malbolge in production. That is not the argument. The argument is that the categorical claim — that AI-generated code isn't "real" programming — is exactly what Malbolge's 27-year history disproves.

The Real Shift Happening

What's actually changing in software engineering isn't that humans are stopping thinking. It's that humans are moving from direct implementation toward supervisory engineering.

Increasingly, the workflow looks like:

humans define goals, constraints, and invariants
machines generate implementation candidates
humans validate behavior empirically

In other words: humans become architects of intent rather than authors of every token.

Malbolge accidentally anticipated this model decades early. Its complexity forced generation-and-validation workflows long before AI coding assistants existed. The language didn't parody programming — it exaggerated trends that modern computing increasingly exhibits:

probabilistic generation
opaque execution layers
machine-assisted synthesis
validation-driven correctness
abstraction beyond direct human reasoning

That's why the language suddenly feels contemporary. Not because engineers stopped caring about correctness. But because correctness and comprehension are not the same thing.

The Most Honest Programming Language Ever Made

Here's the fact that should end every argument:

Ben Olmstead invented a programming language so hostile to human cognition that he himself decided not to program in it.

Imagine that. You design the system. You look at what you've built. And you decide: not for me.

That's not software engineering anymore. That's conceptual art. That's a philosopher handing you a mirror.

And in the AI era, it looks less like a joke and more like prophecy. Because modern software development increasingly resembles orchestration rather than authorship. We already live inside systems too large for complete human comprehension — cloud infrastructure, distributed consensus protocols, neural networks, modern browser engines, compiler ecosystems. Malbolge didn't create this future. It exaggerated it early enough that people mistook it for satire.

The Final Vibe

Critics want the legitimacy of code to be determined by its origin — specifically, whether a human mind traced every token into existence.

Malbolge's 27-year history demonstrates that legitimacy is determined by behavior.

If the system runs, meets its constraints, passes its validation, and serves its purpose — it is legitimate. The question of whether a human, a beam-search algorithm, or an LLM produced the implementation is a question about process, not about correctness.

Malbolge doesn't reward elegant reasoning. It rewards convergence. And the tools that achieve convergence fastest — in 1998, beam search; in 2026, large language models — are not shortcuts around the problem. They are the appropriate instruments for the domain.

So: if you believe vibe coding is laziness, go write a nontrivial Malbolge program by hand. Not with AI. Not with a generator. You, a text editor, and the spec.

I'll wait.

When you come back — empty-handed, weeks later — you'll understand why the rest of us use every tool available.

Malbolge doesn't reward grit. It rewards surrender.

If the program runs, the vibe is correct. Everything else is just ego.

Sources: Ben Olmstead's Malbolge specification (1998). Andrew Cooke's beam-search Hello World (2000). Lou Scheffer's cryptanalysis and cat program (2004). Hisashi Iizawa's 99 Bottles of Beer (2005). Kamila Szewczyk's MalbolgeLisp (2021). Esolang Wiki: Malbolge.