AI Isn't Dumb. It Just Hasn't Lived Yet.

The Wrong Debate

The AI discourse is stuck on a question that doesn't matter: "Is AI smart enough?"

Every few months a new model drops. Benchmarks improve. People argue about whether it's "really" intelligent or "just" pattern matching. The skeptics say it's not smart. The boosters say wait for the next version. Both sides are evaluating the organism when they should be evaluating the machinery.

Here's the question that actually matters: Does this system have the machinery for intelligence to emerge?

Because the first living organisms weren't smart either.

The Krebs Cycle

Every cell in your body runs the Krebs cycle — a metabolic process that converts nutrients into energy. It's essential. Without it, nothing works. But no biologist points at the Krebs cycle and says "that's life."

Next token prediction is the Krebs cycle of AI.

GPT-5. Claude. Gemini. These are extraordinarily sophisticated metabolic engines. Given a sequence of tokens, they predict the next one with remarkable accuracy. They do this drawing on the compressed knowledge of the entire internet. It's genuinely impressive.

But it's the substrate, not the intelligence. The metabolic engine is solved. What's missing is everything that biology built on top of the metabolic engine over 3.8 billion years.

750 Megabytes

Your DNA contains 3.2 billion base pairs. Two bits each. That's about 750 megabytes — less than a single movie file.

The functional coding regions? About 1.5% of that. Roughly 50 megabytes of instructions that actually do something.

From this, your body handles:

• An immune system that fights pathogens that have never existed before
• Metabolic regulation across thousands of chemical processes
• Neural architecture capable of consciousness, language, love, and calculus
• Wound healing, growth, reproduction
• Adaptive responses to temperature, toxicity, starvation, infection
• Development from a single cell into 37 trillion cells across 200+ types

Now consider: a frontier AI model uses hundreds of gigabytes of parameters. Orders of magnitude more raw storage than your entire genome. And it can't remember what you told it yesterday.

The difference isn't size. It's density. Every byte of DNA earned its place by keeping an organism alive long enough to reproduce. Nothing survives in the genome that doesn't work. That's what 3.8 billion years of selection pressure against reality produces — information so dense that 50 megabytes encodes the machinery for anything a human can become.

AI has the storage. It doesn't have the density. Because it hasn't been compressed by reality yet.

Two Primitives

Strip away the complexity and intelligence requires exactly two things:

Priors — Everything that came before you. Your DNA is 3.8 billion years of evolutionary history compressed into a single molecule. Every ancestor that survived a predator is encoded in your fear response. Every ancestor that survived a pathogen is encoded in your immune system. Every ancestor that survived starvation is encoded in your metabolism. You didn't learn any of this. You inherited it. It's the starting point — the pretrained model.

Memory — Everything that happened to you. The hot stove you touched at age three. The person who betrayed your trust. The skill you practiced until it became unconscious. This is what makes you you and not just a generic human. Same genome, radically different person, because the selection pressure of your specific life shaped how the priors express.

Intelligence = Priors + Memory. That's it.

A genome with no lived experience is a newborn — full of potential, zero capability. Lived experience with no evolutionary priors is impossible — you wouldn't know how to breathe.

Map it to AI: model weights are the priors. Trained on the internet. Enormous. But generic. It's a newborn with a very large genome and no life experience. What's missing is the second primitive — lived experience that accumulates, compounds, and shapes how the priors express in a specific environment.

The Evaluation Error

People who say "AI isn't intelligent" are making a first-principles error. They're looking at the organism and evaluating its current capabilities.

Apply the same standard to biology: the first self-replicating molecules weren't intelligent. They were barely stable. Single-celled organisms weren't intelligent. They couldn't think, plan, or reason. If you benchmarked them, they'd score zero on every test.

But they had three things:

1. They could try things — random variation, interaction with the environment
2. They experienced consequences — selection pressure killed what didn't work
3. They passed information forward — survivors' code became the next generation's starting point

That's the complete engine. Eyes, brains, language, civilization — all of it is just what happens when that engine runs long enough.

The right question was never "is this organism smart?" It was "does this system have variation, selection, and inheritance?" If yes — intelligence is a matter of time. If no — fix the machinery, not the model size.

Current AI has the variation. It can try things — and not random things like early molecules bumping into chemistry. It tries things with the compressed knowledge of everything humanity has written. That's an absurdly powerful starting point.

What it's missing: continuous selection pressure from real outcomes, and inheritance that compounds across cycles. It's an organism that can act but can't evolve.

Heuristic, Not Deterministic

This is the deepest reason why engineering alone won't get AI where it needs to go.

Engineering produces deterministic systems — precise rules that handle known scenarios. Given this input, produce that output. Current AI, despite its sophistication, is fundamentally deterministic: the same weights process each input through the same computation.

Evolution produces heuristic systems — approximate rules that generalize to scenarios that have never existed.

Your fear of heights isn't a lookup table of dangerous elevations. It's a heuristic: "high + edge = danger." It fires on cliffs, rooftops, glass floors, VR environments, airplane windows — scenarios no ancestor specifically encountered. It works because it's approximate, not because it's precise.

Your immune system doesn't have a database of every pathogen. It has a heuristic process: generate random antibodies, test them against the invader, massively reproduce what works. It handles novel viruses — ones that have never existed in the history of Earth — on first encounter. Not because the solution was programmed. Because the heuristic discovers the solution at runtime.

This is why 750 megabytes beats terabytes. Heuristics compress better than lookup tables because they don't store answers — they store strategies for finding answers. A fear response is a few neural circuits that cover every height-related scenario that will ever exist. A deterministic height-safety system would need to enumerate every possible cliff, building, ladder, and ledge in the universe.

The real world is non-deterministic. You cannot enumerate all scenarios a person will encounter. The space is infinite. Engineering's instinct is to handle more cases — more data, more parameters, more training. But you can't outrun infinity with scale.

Evolution's answer: don't enumerate. Discover heuristics that generalize. Make them approximate. Make them "good enough." Because good enough across infinite novel scenarios beats perfect across a million known ones.

AI's evolutionary process is in its infancy. We're building enormous deterministic systems and wondering why they're not as capable as a 750 MB heuristic one. The answer is that heuristic systems aren't designed. They're evolved. And evolution requires a loop that current AI doesn't have.

DNA Is a Spec, Not Code

Here's the distinction that changes everything.

DNA doesn't say "when you encounter pathogen X, produce antibody Y." It says "here's how to build a system that figures out antibodies on its own."

It doesn't encode behavior. It encodes the machinery for generating behavior.

The immune system isn't written in the genome. The blueprint for building an immune system is in the genome. The actual immune system is constructed at runtime, shaped by whatever environment the organism lands in. Your immune system and mine share the same spec but are completely different systems — because they were assembled by different lives.

Same with the brain. DNA doesn't contain thoughts, skills, or memories. It contains the spec for building a neural architecture capable of acquiring thoughts, skills, and memories through experience. 750 megabytes doesn't encode everything a human can do. It encodes how to build a machine that can learn everything a human can do.

This is a fundamentally different kind of information:

Code says "do this." It handles scenarios the programmer anticipated. It scales by adding more rules.

A spec says "build a system that figures out what to do." It handles scenarios nobody anticipated. It scales by building better machinery.

Current AI models are code — massive, sophisticated, compressed, but ultimately a fixed function from input to output. DNA is a spec — tiny, generative, and capable of producing systems that handle anything.

Write DNA, Not Code

The entire AI-assisted development conversation is asking the wrong question. "How do we use AI to write better code?" is the wrong question.

The right question: How do we use AI to write better specs?

Code handles what you planned for. A spec builds systems that handle what you never could.

The most powerful AI applications won't be the ones that generate the most lines of code. They'll be the ones that generate the best blueprints — generative documents that describe what a system should be capable of becoming, then hand it to an evolutionary loop that assembles the system through lived experience.

Not "write a function that handles edge case #47." Instead: "here's what success looks like, here's the constraints, here's the selection pressure — now build yourself."

What's Actually Missing

The scaling debate asks "how big should the model be?" That's like asking "how big should the genome be?" The human genome hasn't grown in 200,000 years. What changed was the richness of the environment and the speed of the feedback loop — language, writing, institutions, science. Better selection pressure, not bigger DNA.

What AI needs isn't a bigger model. It's the evolutionary loop:

1. Continuous selection pressure — not one round of RLHF, but ongoing feedback from real outcomes in real environments
2. Memory that compounds — not sessions that evaporate, but persistent state that accumulates and shapes future behavior
3. Inheritance — not static weights, but knowledge that passes from one cycle to the next, getting denser each time
4. Heuristic discovery — not more rules for more cases, but approximate strategies that generalize to cases nobody anticipated

None of these are research problems. They're engineering problems. The hard part — a system that can generate intelligent attempts at solutions across every domain — is already solved. The transformer architecture and next token prediction gave us that.

What nobody has built yet is the environment where that capability evolves into something shaped by one life, continuously improving, accumulating density the way DNA accumulated density over billions of years.

The Punchline

AI's evolutionary process is in its infancy. The models are generation zero. Evaluating them against human intelligence is like evaluating the first replicating molecule against a dolphin. The comparison is absurd — not because the molecule is stupid, but because it hasn't had time under pressure.

The people who say AI isn't intelligent aren't wrong about the current state. They're wrong about what it implies. The first organisms weren't intelligent either. But they could try things, experience consequences, and pass information forward. That was enough. Given time and pressure, everything else emerged.

AI can already try things — with the compressed knowledge of all human civilization behind each attempt. That's not a weak starting point. That's the most powerful starting point any evolutionary process has ever had.

The question isn't whether AI is smart enough. It's whether we'll build the loop that lets it live.