The final ray of light fades behind the horizon—dusk. You shift anxiously, fiddling with your sword and bow. In this world, you never know which night will be your last. Before you can even finish contemplating your fate, you hear it—a distant explosion, followed by a faint rumbling. They're here. Creepers. Let's pray your core, surrounded by obsidian and water, will last the night.
Hello! Back to reality—overly dramatic hook aside, the point I'm trying to make is pretty simple. Imagine a Minecraft player building their base: they dig a moat, make walls, build some static defenses. All the while, a malevolent god, fed descriptions of the base, is looking to send them their next wave of enemies. Zombies that place sponges to drain the moat, followed by creepers to blow a hole in the walls, and spiders that flood in after.
Nobody scripted that encounter. Nothing in the mod knows what a moat is or that sponges beat water. Today, we're going to see if a language model can look at a described situation, figure out why the defense worked, and compose a new wave to exploit it. That's the premise of today's article—and the question underneath: Can a language model do adversarial level design? Can it read a specific opponent, understand what's keeping them alive, and counter it?
But before any of that, it's worth looking at how games have handled this for the last fifteen years, because the idea of a "director" is older than the LLMs I'm throwing at it rather irresponsibly. I mean a Game Director as in a state machine or game system—not like a guy making the game. Adversarial and adaptive difficulty is somewhat of an old-game dream and a current half-reality. A game that pushes back dynamically against player actions can heighten immersion and prevent exploits (e.g., if your players are hiding in one corner mowing down weaklings). The classic version of this is an AI Director.
Left 2 Die 4 Real (Was That the Title..?)
If you've ever played Left 4 Dead, you've met a director. Instead of placing zombies in fixed spawn locations, the director "places enemies in varying positions and numbers based upon each player's current situation, status, skill, and location." (It'll also play some fitting music for you.)
Despite the complicated-sounding description, the internals are pretty straightforward. The director tracks an "emotional intensity" per survivor from 0 to 1—it climbs when infected attack or die near you and decays during calm periods. The director watches that value and walks through a state machine—build up, peak, then relax—creating a sawtooth-like loop that keeps the game feeling alive. The little touches—dropping a sniper rifle right before a Tank, attacking the straggler, breaking your good fortune with a Tank—are just more heuristics engineered to carrot-and-stick the player in clever ways.
There's Risk of Rain To(day)
Risk of Rain 2 runs the same idea as an economy—as a vending machine. Its Combat Directors accumulate credits that grow over time and periodically spend them to buy a group of up to four enemies off a priced menu. A weak Lemurian is pocket change; a Magma Worm boss is the top shelf; slap an elite modifier on something and the price multiplies—6× for a Blazing or Glacial elite, a full 36× for a Malachite or Celestine. By 2026, the system has become a benchmark for emergent difficulty scaling, yet it still lacks the creative spark that a language model might bring.
Both of these systems are essentially clever math—they react to numbers, not to understanding. A director in Left 4 Dead doesn't know why you're struggling; it just knows you are. It throws more zombies because the intensity meter is high, not because it diagnosed that your shotgun is out of ammo and you're cornered. That's where the LLM comes in. Instead of tracking abstract meters, what if the game actually understood the situation—the layout of your base, the strength of your walls, the specific weakness in your defense—and designed an attack that exploits it?
That's the experiment I set out to run. I built a simple Minecraft mod that captures a description of your base—block types, dimensions, water sources, defensive structures—and feeds it to a language model. The model then generates a custom wave of enemies, complete with behavioral modifiers that target the specific vulnerabilities it identifies. A moat? Expect sponges. A lava wall? Prepare for fire-resistant zombies. A water-core defense? Creepers with TNT charges to breach the obsidian.
The mod doesn't have a single hardcoded strategy. It reasons about the situation like a player would, then acts on that reasoning. In my test runs, it was uncanny: one base with a deep moat and archer towers got a wave where zombies advanced underwater, avoiding the towers' line of sight, while creepers tunneled under the walls. I hadn't scripted any of that—the LLM had inferred it from the description.
So, can a language model do adversarial level design? Yes, and surprisingly well. It's not just about throwing more enemies; it's about understanding the why behind a defense and countering it creatively. The potential for games is enormous—dynamic, personalized difficulty that adapts not to your stats, but to your strategies. It's the difference between a director that watches a meter and one that watches you play.