Overview

The constraint above is the entire brief: prompt search needs a repeatable quality signal, but no single metric fully captures human judgment of what makes an LLM output good. A person reading two candidate outputs weighs coherence, faithfulness, tone, and usefulness all at once, in a way no scalar score reproduces exactly. Refusing to solve the problem at all — waiting for a perfect metric before automating anything — means staying stuck with manual spot-checks and a search space too large for a person to explore by hand. The system below accepts an imperfect but repeatable signal, builds a search loop around it, and treats the imperfection as a known limitation to manage rather than a reason to avoid measurement altogether.

Prompts as a population

Prompt search is framed the way a genetic algorithm frames any search: not as picking one best prompt outright, but as evolving a population of candidate prompts across generations. Each candidate is a full prompt — framing, instructions, examples, formatting constraints — treated as a single genotype rather than a bag of independent settings tuned one at a time. A generation starts with a population of candidates, scores every candidate's fitness against a held-out set, and produces the next generation from the fittest members of the current one: some carried forward unchanged, some recombined, some mutated. Across enough generations the population's average fitness rises, and individual bad candidates simply die out rather than needing to be manually noticed and discarded.

This framing matters for a reason that's easy to miss: a genetic algorithm never bets the whole search on one candidate at a time the way manual iteration does. At any point there's a live population of candidates, each representing a different hypothesis about what makes this prompt work — different instruction phrasing, different example counts, different levels of explicit constraint. Some hypotheses turn out to be dead ends; the population absorbs that loss without the search itself losing momentum, because the next generation is drawn from whichever hypotheses are actually paying off.

Why not grid search or random sampling over prompt variants

Prompt variants don't decompose into a small number of independent, orthogonal parameters the way grid search wants them to. Wording, instruction ordering, the number and choice of examples, and how explicitly each constraint is stated all interact — changing one axis changes what the best setting of another axis is. A grid over even a handful of these dimensions, each with a handful of settings, produces a combinatorial explosion of cells, most of which are never worth evaluating, and grid search has no way to skip them: it enumerates the whole grid regardless of what earlier cells already revealed.

Random sampling avoids that combinatorial blow-up by not enumerating anything, but it pays for that by discarding memory entirely: a candidate that scores well in one round teaches random sampling nothing about the next round's candidates. Every sample is drawn blind, no matter how much signal the search has already accumulated. Human intuition does a little better than either extreme, because a person notices when a wording change consistently helps and repeats it — but a person can only hold a handful of variants in mind at once, and can't run the same iterative refinement at population scale, across dozens of candidates and generations, the way a search loop can.

An evolutionary loop keeps the exploration random sampling has and adds back the memory grid search lacks and a person can't scale: high-fitness candidates survive into the next generation and get recombined and mutated, so the search concentrates effort on regions of prompt-space that have already shown promise, while diversity maintenance keeps it from tunneling into just one of those regions too early.

Elitism and crossover

Two mechanisms carry information forward from one generation to the next: elitism, which protects it, and crossover, which recombines it.

Elitism means the top-performing candidates in a generation are copied unchanged into the next generation, bypassing mutation and crossover entirely. Without it, a genetic algorithm can lose its best-found solution to bad luck — a strong candidate crossed with a weak one, or mutated in a way that happens to degrade it — with no guarantee a later generation ever rediscovers something as good. Elitism makes fitness effectively monotonic across generations: the population's best candidate never gets worse, only replaced by something at least as good.

Crossover recombines two strong candidates into offspring that inherit parts of both. In practice this means splitting a prompt into sections — the framing, the instructions, the examples, the output-format constraint — and swapping some sections between two high-fitness parents while keeping others intact. A parent whose instructions score well but whose examples are weak, crossed with a parent whose examples are strong but whose instructions are muddled, can produce an offspring that improves on both — a candidate neither hand-tuning nor mutation alone was likely to reach, because it requires recognizing which section of a prompt is responsible for which part of the fitness score and swapping only the section that isn't currently working.

Adaptive mutation weighting

Mutation is what keeps the search exploring rather than just recombining what elitism already preserved, but a single fixed mutation rate is a bad compromise no matter what value it's set to. Set it too high and mutation reliably wrecks otherwise-good candidates faster than crossover can produce new good ones; set it too low and the search stalls, unable to escape the neighborhood of wherever it started.

The mutation step here doesn't use one rate — it's a set of distinct operators (reword a sentence, reorder instructions, add or remove an example, tighten or loosen a constraint, change an output-format instruction), each carrying its own weight, and the weights adapt across generations based on which operators actually produced fitness gains recently. An operator that keeps producing improvements gets sampled more often; one that keeps producing regressions gets sampled less. That mirrors what a person tuning prompts by hand already does instinctively — notice that shortening instructions keeps helping, and lean into it — except applied consistently across the whole population instead of relying on one person's memory of what worked last time.

def update_weights(weights, operator_deltas, learning_rate=0.1):
    # operator_deltas: mean fitness change attributed to each
    # mutation operator over the last generation
    for op, delta in operator_deltas.items():
        weights[op] *= math.exp(learning_rate * delta)
    total = sum(weights.values())
    return {op: w / total for op, w in weights.items()}

Reweighting mutation operators by the fitness delta they produced

The adaptation also tracks the coarse shape of the search over time: early generations, far from any local optimum, benefit from weight on structural mutations — reordering, adding or removing whole sections — that can jump to a meaningfully different candidate. Later generations, once the population has converged toward a strong region of prompt-space, benefit more from weight on fine-grained wording mutations that refine rather than restructure. A fixed weighting can't track that shift over the course of a run; an adaptive one does.

Diversity maintenance

Left alone, a genetic algorithm's own selection pressure works against it: if the fittest candidates are always the ones reproduced, and their offspring resemble them, a population can converge within a handful of generations onto near-copies of a single early winner. At that point the search has effectively stopped searching — it's re-sampling small variations around one point in a large space, and any better prompt that happens to live in a different region never gets explored, because nothing left in the population is close enough to discover it by mutation.

This setup treats that collapse as a fitness ceiling to actively guard against, not a symptom to notice only after it happens. Selection factors in more than raw fitness: candidates similar to others already well-represented in the population are penalized relative to candidates that are novel, so two prompts scoring the same raw fitness don't get equal weight if one is redundant with several other candidates and the other is the population's only representative of its approach. The population is also seeded with occasional new random candidates each generation, unrelated to anything already in the pool, so a region of prompt-space the current population never wandered into still gets a chance to be sampled.

The tradeoff is real and worth naming directly: protecting diversity means the search sometimes keeps a lower-fitness candidate alive over a higher-fitness near-duplicate, which slows how fast the population's average fitness climbs. That's a deliberate trade of short-term convergence speed for a lower chance of settling on a local optimum that isn't actually the best prompt available.

Multi-objective fitness scoring

A single number for "how good is this prompt" has to come from somewhere, and picking the wrong single number is a fast way to optimize a search into something worse than what a person would ever have shipped by hand — an output that's technically on-topic but rambling, or terse to the point of losing substance, can still score well on a metric that only checks topical relevance.

Fitness here is multi-objective: it balances a learned semantic-similarity score against a reference output (BLEURT — a metric trained to predict human judgments of text quality rather than relying on the surface n-gram overlap older metrics like BLEU use), output length relative to a reasonable target range, and vocabulary characteristics that catch degenerate outputs a semantic-similarity score alone can miss, such as excessive repetition or a drift into a register that doesn't match the reference examples.

def fitness(output, reference, target_length):
    semantic = bleurt_score(output, reference)          # 0..1
    length_penalty = length_deviation(output, target_length)
    vocab_penalty = vocabulary_degeneracy(output)
    return (
        W_SEMANTIC * semantic
        - W_LENGTH * length_penalty
        - W_VOCAB * vocab_penalty
    )

Fitness as a weighted combination, not a single learned score

Every candidate prompt is scored this way against a held-out set of examples it was never optimized against directly, generation after generation, so the reported fitness is at least an estimate of how the prompt performs on inputs the search hasn't already seen and adapted to, not just on the handful it's been tuned against. That held-out discipline is what turns the loop from a search that overfits its own evaluation set into a search whose winners are more likely to generalize to genuinely new inputs.

Tradeoffs and limitations

None of this makes prompt search objective, and being honest about what it doesn't solve is part of the design:

• Any learned similarity metric, BLEURT included, is itself an approximation of human judgment trained on a finite, possibly biased sample of human ratings — not a ground truth, and a candidate that exploits its blind spots can score well without actually being better.
• The relative weights in the multi-objective fitness function are a judgment call, not a derived quantity — nothing in the math says semantic quality should count for more or less than length or vocabulary, and a poorly chosen weighting steers the whole search toward the wrong tradeoff without raising any error.
• Genetic search is compute-heavier than a single hand-tuned pass by design — many candidates, many generations, each candidate scored against a held-out set, means far more LLM calls and scoring passes than trying a handful of prompts by hand.
• Diversity maintenance trades convergence speed for avoiding local optima on purpose — a population without it converges faster on average, just with a higher chance that what it converges on isn't the best prompt available.
• A held-out set only generalizes as well as it represents real usage; a narrow or unrepresentative held-out set produces a winning prompt that looks strong on paper and underperforms the moment real traffic differs from what the set covers.
• Crossover and mutation operators encode assumptions about what a meaningful prompt edit looks like — reword a sentence, swap an example block, tighten a constraint — and the search can only find what its operators are capable of producing; an operator set that never considers restructuring the whole framing will never produce that restructuring, no matter how many generations it runs.

References and further reading

None of the mechanisms here are novel on their own — they're standard building blocks from evolutionary computation and NLG evaluation, applied together to prompt search specifically:

• Wikipedia — Genetic algorithm
• Sellam, Das, Parikh — BLEURT: Learning Robust Metrics for Text Generation (arXiv:2004.04696)
• google-research/bleurt — official BLEURT implementation
• Wikipedia — Multi-objective optimization
• Zhou et al. — Large Language Models Are Human-Level Prompt Engineers (arXiv:2211.01910)