How Do We Create Software?

Three Paradigms

Path 1: Traditional

Hand-Coding

Human writes every line.
Slow, predictable, brittle.

👥 5–10 engineers

Weeks → Months

✓ Full control
✗ Doesn't scale to complexity

Path 2: AI-Assisted

"Vibe Coding"⚠

LLM generates code.
Fast, unreliable, hallucinates.

👥 1 engineer

Hours → Days

✓ Rapid prototyping
✗ No performance guarantees

Path 3: Evolutionary

Code Competes to Survive

Mutation, selection, iteration.
Emergent, adaptive, measurable.

👥 1 evolution engineer

Hours → Days

✓ Discovers novel strategies
✓ Human-readable output

What Is Code Evolution?

Natural Selection — Applied to Algorithms

Same algorithm. Different substrate.
DNA → Source code  ·  Predator → Opponent  ·  Generations → Rounds

Evolutionary Paradigms in Software

Biology rejected two of these. Code doesn't have to.

Biology rejected Lamarck and Orthogenesis.
But in code, we can inherit learned behaviors. We can guide mutation.
Evolution is a tool, not a dogma.

SwarmEvolve: The Test Arena

Autonomous Drone Swarms — Where Code Fights to Survive

The Experiment

How We Set Up the Evolutionary Loop

① Generate — LLM writes C++ drone AI (Claude / Gemini)

② Compile & Guard — Inject loop guards, compile in sandbox

③ Simulate — GPU-accelerated 1000-tick combat

④ Evaluate & Select — Fitness score → winners survive → loop

🔵 Blue Fleet vs 🔴 Red Fleet — Simulated engagement

Experiment Setup

M25: 95-round competitive co-evolution

Can a 66-line underdog evolve to beat a 204-line champion? Let's find out →

The Result: Underdog Wins

Evolution found what engineering didn't

Team B (red) overtakes Team A (blue) at Round 31

🏆 Final Score

−0.8

Team B start

→

+1.0

Team B finish

Team B went from losing 8 out of 10 battles to dominant winner — in 95 rounds of unguided evolution.

📈 Evolution Trajectory

R1–R30: Losing badly. Trying random approaches.

R31: Breakthrough. Formation Spread mutation accepted.

R32–R95: Dominance. Team A never recovers.

💡 What Made the Difference

Formation Spread — a single parameter change:
min_spacing = 80
Drones stopped clustering, became harder to hit en masse. No human ever designed this tactic.

The recipe worked. Evolution found a way.

Emergent Behavior

Discovered, not programmed

These tactics have names because we observed them. The LLM didn't plan "zone control." Across both teams: 55 mutation attempts. 8 accepted. This is one of them.

From Pursuit to Zone Control

Each phase added a capability — the breakthrough was their combination

Communication alone couldn't win. Prediction couldn't dominate.
Evolution stacked them in order — and the combination was the breakthrough.

Code Archaeology

What Changed Between Round 1 and Round 31?

// Simple pursuit
for (int i = 0; i < num_enemies; i++) {
    if (!enemies[i].alive) continue;

    float dx = enemies[i].x - my_x;
    float dy = enemies[i].y - my_y;
    float dist = sqrtf(dx*dx + dy*dy);

    if (dist < closest_dist) {
        closest_dist = dist;
        target_id = i;
        move_x = dx;
        move_y = dy;
    }
}

// Normalize and move
float mag = sqrtf(move_x*move_x + move_y*move_y);
if (mag > 0.01f) {
    move_x /= mag;
    move_y /= mag;
}

// Formation Spread with repulsion
float repulse_x = 0.0f;
float repulse_y = 0.0f;

for (int i = 0; i < num_allies; i++) {
    if (i == my_id || !allies[i].alive) continue;

    float dx = my_x - allies[i].x;
    float dy = my_y - allies[i].y;
    float dist = sqrtf(dx*dx + dy*dy);

    const float min_spacing = 80.0f; // ← THE KEY LINE

    if (dist < min_spacing && dist > 0.01f) {
        float push_x = dx / dist;
        float push_y = dy / dist;
        float strength = (min_spacing - dist) / min_spacing;
        repulse_x += push_x * strength;
        repulse_y += push_y * strength;
    }
}

// Combine pursuit + repulsion
move_x = 0.6f * pursuit_x + 0.4f * repulse_x;
move_y = 0.6f * pursuit_y + 0.4f * repulse_y;

One constant. 80 units. Emergent zone coverage.
The swarm didn't know it was inventing a strategy. It just... worked.

Evolution Engineering

A new discipline — designing the system that designs the code

Evolution doesn't just happen. Someone has to design the rules of the game: what counts as success, when a mutation gets accepted, how to keep the system from grinding to a halt. That person is an Evolution Engineer.

Six dials. Turn them differently — get a different evolution.

Decision 1: The Genome Question

One shared codebase, or one per individual?

We picked shared. Speed of iteration mattered more than diversity for one experiment.

Decision 2: The Evolutionary Loops

Two clocks tick at different speeds

Inner loop asks: "Did this mutation help?"
Outer loop asks: "Who is the opponent now?"

Decision 3: The Fitness Function

What you reward IS what you get

Decision 4: Preventing Stasis

How do you keep evolution from stopping?

Once a system finds a "good enough" answer, mutations stop helping. Without intervention, fitness flatlines.
Nature has five tricks. Engineers borrow them.

We bet on Red Queen pressure — alternating opponents, forcing each to keep adapting.

If the experiment had stalled, we had four backup mechanisms ready.

Decisions 5 & 6: The Guardrails

What's allowed to change? When do we stop watching?

Bounds = "what" can change. Termination = "when" we stop watching.

The Future of Evolutionary Code

If we're right, this is just the beginning

What if all software was alive?

Credits & Reproduction

Standing on the Shoulders of Giants

Intellectual Foundations

• Charles Darwin — Natural selection, Origin of Species
• Gregor Mendel — Genetics, inheritance mechanisms
• Stephen Jay Gould — Punctuated equilibrium (1972)
• Leigh Van Valen — Red Queen hypothesis (1973)
• Sewall Wright — Fitness landscapes (1932)

Tools & Technologies

• Claude Sonnet 4 — Mutation planner
• Claude Haiku 4.5 — Code writer
• OpenACC — GPU parallelization
• C++17 — Implementation language

Reproduce This Experiment

git clone https://github.com/leybzon/SwarmEvolve
cd SwarmEvolve
python3 scripts/evolve_coevolve.py \
  --init-champion-a data/runs/m22_rq1_100gen/gen_0033/candidate.cpp \
  --init-champion-b src/baselines/pursuit_v1.cpp \
  --planner-model claude-sonnet-4-20250514 \
  --coder-model claude-haiku-4-5 \
  --rounds 100 --n-matches 10 --seed 42 \
  --acceptance-mode relative --strict-reflection

• GitHub: github.com/leybzon/SwarmEvolve
• License: MIT (open source)

Questions? Open an issue on GitHub or contact Gene Leybzon.