This April, Google DeepMind released AlphaEvolve. Chinese-language media ran headlines implying DeepMind had unleashed another AGI: an AI that modifies its own code, already running in Google’s data centers for a year.
Those numbers aren’t made up. But the “AI modifying its own code” framing buries the most important thing. What AlphaEvolve actually does is stitch together two technical approaches that each had a fatal flaw, in a way you can understand at a glance. Understanding that stitch matters more than any benchmark number.
By the early 2000s, computers were already orders of magnitude faster than human hands. But if you asked an ML researcher “can a computer automatically design a better neural network architecture,” they’d say it’s too hard. Not because computers weren’t fast enough. Because nobody knew how to encode “better architecture” into a score a computer could compute automatically.
The breakthrough in Neural Architecture Search didn’t come from smarter models. It came from one realization: define “good architecture” as “validation accuracy,” define evaluation as “train a small model with this architecture and check accuracy,” define candidate generation as “add a layer or tweak a parameter from the last high-scoring architecture,” and run the loop. A classic NAS paper describes this clearly: a controller generates sub-network descriptions, sub-networks are trained, validation accuracy is fed back as a reward signal, and the controller updates to generate the next round.
NAS can do many things. It found language model architectures more efficient than human-designed ones. It discovered image classification variants more accurate than ResNet. But it had a fatal flaw, and it died ugly.
The flaw is in the mutation operator. When NAS generates a new candidate, it’s doing random operations: add a layer, remove a layer, change a hyperparameter. None of these operations understand “why the last architecture worked” or “what this change means semantically.” It’s just bumping around. In a small enough search space, bumping around works. But once program complexity passes a threshold, say from choosing architecture to writing scheduling logic, the mutation operator goes completely blind. The probability that random character changes produce code that compiles and beats baseline is near zero.
This is why NAS can design architectures but can’t write algorithms. The mutation step collapses the moment search graduates from “pick parameters” to “write code.”
Around the same time, another path was developing. Not blind computer mutation, but an AI that can code doing the work for you.
From 2023 to 2026, coding agents went from demos to daily tools. Claude Code, Cursor, OpenCode all share the same paradigm: you describe a goal, the agent reads the code, writes a patch, runs tests, checks results, iterates. Give Claude Code an optimization target, “reduce this code’s latency below 200ms,” and it can do it. It tries several approaches, runs benchmarks, compares numbers, picks the best.
This path is far more flexible than NAS. The LLM isn’t doing random mutation. When it reads code, it understands semantics: “the loop count depends on array length, switching to tiling should reduce index computation.” Every change has direction because the model understands code.
But it has a fatal flaw too. When Claude Code optimizes code, only one candidate is evolving. Try one direction, good, go deeper. Not good, back up, try another. This works fine for simple search spaces. But when the optimization target has multiple dimensions, lower latency but worse throughput, less memory but narrower correctness boundaries, a single candidate can’t traverse several mutually exclusive paths simultaneously. More critically, Claude Code’s sense of direction comes from the model’s internal judgment. When the model thinks “that last change worked, keep going,” nobody can tell it that five more steps will hit a dead end. You’re asking a smart person to climb a mountain blindfolded. They climb faster than a blindfolded person who can’t see, but they still walk into dead ends.
What AlphaEvolve does, stripped down, is one sentence. Take the stupidest component of NAS, the mutation operator, rip it out, and replace it with an LLM. The evolutionary algorithm’s framework stays the same: candidate pool, evaluator scoring, selection, reproduction, elimination. Mutation is no longer random. It becomes an LLM reading the current high-scoring programs, reading feedback, reading the task description, reading failure history, then generating a semantically directed diff.
AlphaEvolve’s technical report describes this mechanism: the system samples programs from the Program database to build prompts, LLMs generate code diffs, evaluators score them, high-scoring programs are written back to the database. “Human defines what. AlphaEvolve figures out how.” The LLM handles “think of a change.” The evolutionary framework handles “decide which ideas survive.” Clear division of labor.
This synthesis solves the problems of all three paths. NAS’s mutation blindness is covered by the LLM’s semantic understanding. NAS no longer relies on random bumping. The mutated code probably compiles, means something, and goes in the right direction. Claude Code’s single-point search is replaced by population search. AlphaEvolve’s candidate pool holds five to ten different directional approaches competing simultaneously. When one path hits a wall, others in the pool keep climbing. It’s not “one smart person climbing a mountain.” It’s “a group of smart people climbing different slopes, periodically picking the highest climbers and having the rest continue from their altitude.”
AlphaEvolve’s published cases were found this way. A scheduling heuristic for Borg. A matrix multiplication tiling strategy for Gemini’s training kernel. A Verilog circuit optimization inside a TPU. A low-level GPU instruction reordering for FlashAttention. These problems share one property: correctness can be verified automatically, but nobody knows what the optimal implementation looks like. AlphaEvolve doesn’t need to know the optimal shape. It just needs a scoring evaluator and an LLM that turns history into semantic variants. The search itself is carried by the evolutionary framework.
Understand this synthesis and you stop getting misled by headlines.
AlphaEvolve doesn’t modify model weights. Gemini is the mutation operator inside it, not the thing being updated. What gets updated are the algorithm code in the candidate program pool, plus some prompt context. The phrase “AI improving AI” actually means “AI-written code optimized AI training infrastructure.” It does not mean “a model recursively rewriting its own brain.”
The difference between AlphaEvolve and Claude Code isn’t about good versus bad. “Can modify code” isn’t the dividing line. The dividing line is: are you looking for one feasible solution, or are you exploring a feasible space for the optimum. The first needs a single agent. The second needs population search plus an evaluator. Not better or worse. Different.
The reason to keep watching AlphaEvolve isn’t “AI is evolving.” It’s that it proved one thing: splitting the search framework from semantic understanding, and having them work in their respective lanes, is more effective than letting one model handle everything. The LLM proposes. The evolutionary framework selects. This division means the LLM doesn’t need to “understand algorithm optimization better than humans.” It just needs to “modify code better than random mutation.” Narrow the target, and the results go up.
One final note worth keeping in mind. AlphaEvolve has only published details on 13 successful cases. Over 37 failed cases remain unpublished. Without failure case details, we can’t judge which problems it fails on. The assessments above are based on the mechanism design in available materials, not on generalization guarantees across all problems.
In one sentence: traditional evolutionary algorithms are too dumb. A single LLM is too narrow. AlphaEvolve plugs the LLM into the evolutionary algorithm’s mutation slot, and for the first time, machine search has a sense of direction.