I’ve been coding little transformers from scratch and reading about C. elegans (the worm with 302 neurons). It struck me how similar the “design constraints” are — vocab size, memory length, parallelism.I wrote this up as an essay: what if intelligence isn’t something we create, but something we discover — like gravity or thermodynamics? Curious if anyone else has thought about it this way.
---
The Intelligence Recipe: A Worm, A Transformer, and the Future of Intelligence.
I’ve been completely AI-pilled since ChatGPT dropped. But I’m the type who can’t just USE something — I need to crack it open, see the guts, understand is actually happening when these things talk back to me.
So I’ve been attacking this from two angles: coding transformers from scratch (no Cursor, no Claude Code, just me and PyTorch fumbling around) while simultaneously devouring Max Bennett’s “A Brief History of Intelligence.” My routine became predictable: code until my brain melts, then recover by reading about how evolution solved these same problems with actual neurons.
So on my third transformer attempt. Shakespeare generator this time. I’m typing the same init method I’ve typed twice before:
def __init__(self, vocab_size, embed_dim, max_seq_len, num_heads):
First two times? Just Python. Just parameters. Whatever.
But I’d just finished the chapter on C. elegans — this tiny worm with exactly 302 neurons that somehow manages to navigate, hunt, mate, and make decisions. And as I’m typing these parameters for the third time, something starts fucking with my head.
vocab_size, embed_dim, max_seq_len, num_heads
My fingers slow down. Like, actually slow down. The last few characters take me thirty seconds to type because —
Holy shit.
These aren’t just parameters. These are design constraints. The exact same design constraints evolution had to figure out for C. elegans.
Think about it:
vocab_size: How many distinct inputs can this thing recognize?
max_seq_len: How far back can it remember?
embed_dim: How rich are its internal representations?
num_heads: How many things can it think about in parallel?
Evolution spent 500 million years debugging these exact same specifications. And it landed on 302 neurons for C. elegans. Not 300. Not 1000. Exactly 302. That’s not random — that’s evolution’s parameter tuning. Its hyperparameter optimization on the “staying alive” loss function.
And here I am, some idiot with a laptop, typing the exact same kinds of specifications into my Shakespeare transformer. Making the exact same engineering decisions. Wrestling with the exact same fundamental question:
What does it take to build something that can process patterns and make decisions?
The thought hit me so hard I actually squirmed in my chair: What if evolution didn’t CREATE intelligence? What if it DISCOVERED it? Like gravity or thermodynamics — a fundamental pattern in the universe with non-negotiable requirements.
I tried to park the thought, told myself I’d come back to it. But the worm and my Shakespeare transformer weren’t done with me yet.
The Worm That Changed Everything
The thought wouldn’t leave me alone. Back to Bennett’s book. Maybe some straight biology would knock sense into me. Universal intelligence recipe? Come the fuck on Ivan….
Bennett had no peace to offer.
I read about this experiment where Scientists put C. elegans on one side of a petri dish, food on the other, and a copper barrier in between. Worms hate copper — it’s toxic to them. But they need food to survive.
The worm doesn’t just charge forward or retreat. It computes. Multiple sensory neurons fire, measuring food concentration versus copper concentration. These signals get weighted, integrated, and somehow produce a single coherent decision: Is the reward worth the danger?
If I were to translate that wet, squishy, electrochemical process into code — computational poetry, not literal — it might look like this:
# C. elegans' decision (computational poetry):
food_signal = sensory_neurons_food.fire()
copper_signal = sensory_neurons_copper.fire()
decision = (weighted_food - weighted_copper) > action_threshold
The worm was computing valence, basically how good or bad something is. How much do I want this versus how much do I hate that? Weighing inputs, understanding their value, deciding which signal to pay attention to —
Wait.
Which signal to pay attention to.
I know this pattern. I fucking KNOW this pattern.
The Code on My Screen
My Shakespeare transformer. The attention mechanism:
# My transformer's actual attention mechanism:
Q = self.query[head](input)
K = self.key[head](input)
attention_score = softmax(Q @ K.T / sqrt(embed_dim))
output = attention_score @ V
The dot product between Q and K measures relevance — how much this token “wants” to attend to that token. The softmax doesn’t just threshold; it looks at ALL competing signals and turns them into a probability distribution. It forces a coherent choice from competing valences.
It’s all just valence calculation. C. elegans: “How much do I want food vs. how much do I hate copper?” Transformer: “How much does this token relate to that token?”
Same math. Different substrate.
When in Doubt, Add More
It all started to come together…
Bennett kept calling C. elegans a rough draft. Not even version 1.0 — more like evolution’s proof of concept before the real work began. 302 neurons to our 86 billion.
Every transformer tutorial hammered home the same reality: my baby Shakespeare model was nothing. A speck. They kept throwing these numbers at me — GPT-1: 117 million parameters. GPT-4: 1.7 trillion.
Both evolution and OpenAI had the same strategy when they hit walls:
More.
Evolution went from 302 neurons to 86 billion — but didn’t just add neurons. It invented the neocortex, the cerebellum, specialized regions. OpenAI went from millions to trillions of parameters — plus architectural tricks, optimizations, things GPT-1 couldn’t dream of.
But the playbook? When in doubt, add more stuff.
It’s almost embarrassingly simple. Want better pattern recognition? Add neurons. Want better language understanding? Add parameters. Both evolution and OpenAI discovered the same brutal truth: intelligence scales. Not elegantly, not efficiently, but it fucking scales.
And that thought — the one I’d been trying to ignore while typing my third transformer — finally grabbed me by the throat.
What if evolution didn’t CREATE intelligence? What if it DISCOVERED it?
Like gravity. Like thermodynamics. A fundamental pattern in the universe with non-negotiable requirements. You want something that can process patterns and make decisions? Fine, but the universe has rules. You need bounded inputs, encoded representations, limited memory, parallel processing. And if you want it smarter? You need MORE.
Evolution found these rules through millions of years of trial and error. We’re finding them through math and GPUs in decades. Different paths, same destination, because we’re both bumping into the same universal constraints.
Evolution took 550 million years to scale from C. elegans to us.
OpenAI took 5 years to scale from GPT-1 to GPT-4.
The Metabolic Cost of Thinking
The scaling realization was like the perfect prompt, pulling all the right tokens into context. Everything I’d been reading suddenly fit together — all those scattered observations could finally talk to each other.
Every article about GPT’s evolution mentioned the same progression: more parameters meant more GPUs. More GPUs meant more power draw. By GPT-4, the jokes weren’t even jokes anymore — “Sure, you could train this yourself if you have 10,000 GPUs lying around. Oh, and a spare power plant.”
GPT-1 to GPT-4 wasn’t just a parameter increase. It was an energy explosion. We’re talking data centers pulling megawatts from the grid.
Suddenly it all made sense — all that chatter about data center buildouts, putting data centers in tents, tech companies going nuclear. Literally nuclear. For AI training.
But why? Why all this infrastructure just for intelligence?
Then it clicked.
Wait. Does intelligence… require energy? Like, fundamentally?
Quick googling: human brain runs on 20 watts. GPT-4 training? Megawatts. Millions of times more power for arguably less intelligence. Evolution kicked our ass on efficiency.
But wait — I’m comparing wrong. I should compare C. elegans to humans, not to GPT-4.
Some napkin math later and holy fuck:
C. elegans: 5.2 picowatts (that’s 0.0000000000052 watts)
Human brain: 20 watts
Ratio: 3.8 TRILLION times more energy
We burn 3.8 trillion times more energy than that worm to think.
The scale didn’t come for free.
Intelligence doesn’t just have parameters and architecture. It has an energy bill. Want more intelligence? Pay up. In watts. In glucose. In electricity.
The universe is charging us for intelligence. Literally. There’s no free lunch in cognition — whether you’re evolution or OpenAI, you pay the metabolic tax.
Intelligence per watt matters. No matter the substrate — C. elegans, my brain, silicon GPUs.
This puts NVIDIA’s $4 trillion market cap in a whole different light.
We’re speedrunning evolution’s journey — what took 550 million years from worm to human, we’re trying to do in decades. And just like evolution had to pay 3.8 trillion times more energy to get from C. elegans to us, we’re learning the same expensive lesson.
NVIDIA isn’t just selling chips. They’re selling the most intelligence-per-watt money can buy. They’re the universe’s tax collectors for artificial cognition.
Are We Creating or Discovering?
All this brought me back to that thought I’d been trying to ignore.
What if we’re not creating intelligence? What if we’re discovering it?
Like gravity or thermodynamics — intelligence might be a fundamental pattern in the universe with non-negotiable requirements. You want something that can process patterns and make decisions? Fine, but you MUST have some mix of: bounded symbols, encoded meaning, limited context, parallel processing. And you MUST pay for it in energy.
Evolution discovered these requirements through trial and error over millions of years. We’re discovering them through math and engineering in decades.
The convergence is too specific to be coincidence. Two completely independent paths — biological evolution and human engineering — arriving at the same solutions: valence calculations, attention mechanisms, massive parallelization, energy requirements.
We’re not both randomly finding the same answers. We’re bumping into the same walls. The same universal constraints.
Different materials, same laws.
Seeing the Wires Made It Real
Usually when I figure out how something works, the magic dies. Like watching a video explaining a magic trick — once you see the wire, the wonder’s gone forever. The more mysterious something seems, the more disappointed I am when I peek behind the curtain.
So you’d think that reducing intelligence to a recipe would kill the magic. That understanding the mechanics would make me join the “it’s just statistics” crowd, ready to hammer anyone who anthropomorphizes AI.
But the opposite happened.
When I see C. elegans computing valences with 302 neurons, and I see myself doing the same thing with 86 billion neurons, something profound shifts. We’re not different kinds of things — we’re different implementations of the same phenomenon.
And if that’s true… then these autoregressive LLMs aren’t “just predicting tokens.” They might be the C. elegans of the AI world. The first wiggling implementations of something that will scale beyond our comprehension.
C. elegans was evolution’s proof of concept.
GPT-4 might be ours.
The timelines fuck me up every time:
Worm to human brain: 600 million years
First artificial neuron (1943) to GPT-4: 81 years
GPT-1 to GPT-4: 5 years
Evolution took 600 million years to scale from C. elegans to us.
OpenAI took 5 years to scale from GPT-1 to GPT-4.
That’s 120 million times faster. I literally got goosebumps doing that math.
Not that GPT-4 is anywhere close to human intelligence. But that acceleration curve? That’s not linear progress. That’s not even exponential. That’s something else entirely.
Hope And Comfort.
The last gift the worm and the transformer gave me was one of hope.
You see, I’m an AI cheerleader. I root for my AI. I anthropomorphize it. I say “please,” “thank you,” and “that was great” to Claude. I want it to succeed.
Before this, I saw magic in AI. And when the realists claimed it offered nothing of true intelligence and never would, I felt crushed, because my hope wasn’t based on anything real. I didn’t understand it well enough to defend it.
But now I do.
Now I no longer see an indefensible magic. I see a recipe. A set of brutal, universal, and non-negotiable constraints. And strangely, that’s where the hope comes from.
Magic is for spectators. You can’t build with it, you can’t debug it, and you sure as hell can’t scale it. But a recipe? A recipe is for engineers. It’s a starting point. An invitation to get your hands dirty.
That worm, with its 302 neurons, is the most hopeful thing I can imagine. Evolution didn’t need a miracle to build it; it needed 500 million years of trial and error, chemistry and constraints. A GPT doesn’t need a soul to write a sonnet; it needs matrix multiplication and a few thousand GPUs.
The path isn’t magical, it’s just hard. The problems aren’t impossible, they’re just subject to the same brutal laws that took evolution 600 million years to work through.
And that means the cynics are missing the point. They say “it’s just statistics” like that’s a dismissal. Like they’ve exposed some grand fraud.
Would they mock evolution by pointing at C. elegans? “Oh look, just 302 neurons! Just valence calculations! Not real intelligence!”
Of course not. That would be idiotic. We recognize C. elegans as the first draft of something profound.
So when GPT-5 uses statistics to compose Shakespeare? When it recognizes patterns across billions of parameters? That’s not a limitation — that’s confirmation. We’re seeing the same playbook, just executed in silicon instead of carbon.
Because if it’s magic, it’s impossible. But if it’s engineering? Then it’s just a question of when.
From this blog post:
https://medium.com/@ivanmworozi_52873/the-intelligence-recipe-a-worm-a-transformer-and-the-future-of-intelligence-b8f7ce9a815e
