---
title: "Northwestern Catches LLMs Recycling the Same Code in Evolutionary AI"
subtitle: "A new study finds LLMs used as mutation operators in genetic programming reliably converge to the same structural templates, undermining the diversity that evolutionary search depends on."
url: "https://alphasignal.ai/news/northwestern-catches-llms-recycling-the-same-code-in-evolutionary-ai"
author: "AlphaSignal Newsroom"
author_url: "https://alphasignal.ai/editorial-team"
company: "AlphaSignal"
company_url: "https://alphasignal.ai/company/alphasignal"
published: "2026-06-03T00:00:00.000Z"
updated: "2026-06-11T03:48:21.912Z"
type: "Paper"
topics:
  - "Development"
  - "Reasoning"
subtopics:
  - "Code Generation"
  - "Test Time Compute"
upvotes: 1502
source_url: "https://arxiv.org/abs/2606.05408"
comments: 0
truncated: true
---

# Northwestern Catches LLMs Recycling the Same Code in Evolutionary AI

> A new study finds LLMs used as mutation operators in genetic programming reliably converge to the same structural templates, undermining the diversity that evolutionary search depends on.

There is a growing wave of systems that use LLMs as mutation engines inside evolutionary algorithms -- from [Evolution through Large Models](https://arxiv.org/abs/2206.08896) to Google's AlphaEvolve and FunSearch. The pitch is compelling: instead of random bit-flips, you get semantically intelligent edits that understand what a program does. But a new paper from Northwestern University and Augustana College asks a deceptively simple question: when you keep asking an LLM to mutate a program, does it actually explore new territory, or does it just keep rewriting the same thing in slightly different words?

The answer, it turns out, is mostly the latter -- and the numbers are stark enough to matter for anyone building LLM-in-the-loop optimization systems.

## The trap at the heart of LLM-driven evolution

Evolutionary algorithms rely on the premise that simple variation operators, applied iteratively, can give rise to a vast and diverse space of candidate solutions. Among these operators, mutation plays a central role, continually injecting new genetic material and enabling populations to explore beyond their current configurations. LLMs seemed like a natural upgrade to this process: they can make changes that preserve semantic intent, respect syntax, and even reason about what a program does. LLMs are well-placed to act as selection and mutation operators, as they have been trained on vast datasets of human knowledge and culture, offering a mechanism through which to make semantically meaningful mutations via text. 

But there is a catch. Multiple independent LLM ideation sessions frequently converge around similar themes and concepts. This convergence results in a narrow exploration of the ideation space, and the computer science literature broadly refers to this phenomenon as "mode collapse" -- a fundamental limitation of current LLM design. The new paper, [_Mutation Without Variation_](https://arxiv.org/abs/2606.05408), is the first to rigorously quantify this collapse specifically in the context of program evolution, with a controlled experimental setup designed to isolate the mutation operator itself.

_Preview only. Full text requires an AlphaSignal Pro account._

## Sources

- [Mutation Without Variation: Convergence Dynamics in LLM-Driven Program Evolution](https://arxiv.org/abs/2606.05408)
- [Mutation Without Variation (full HTML paper)](https://arxiv.org/html/2606.05408)
- [Examining and Addressing Barriers to Diversity in LLM-Generated Ideas](https://arxiv.org/pdf/2602.20408)
- [Open-Endedness is Essential for Artificial Superhuman Intelligence](https://arxiv.org/pdf/2406.04268)
- [LMCA Source Code Repository](https://github.com/can-gurkan/lmca)