AI is a terrible game designer, but it’s a fantastic bulldozer.
This week, I used an AI coding agent to speedrun a prototype for a cozy-survival card game called Generations of Doom. The goal was an aggressive stress test: How far could an LLM get building a React frontend with a custom handwritten UI, drag-and-drop mechanics, and a progressive damage state for the main base before it completely collapsed?
It actually nailed the UI. But then we hit the “Memory Wall.”
If you are experimenting with AI for indie game development, you already know the honeymoon phase. The AI scaffolds out your menus perfectly. It writes your boilerplate CSS in seconds. But the second you ask it to manage a deeply interconnected game loop, the illusion shatters. Here is why using AI to prototype games is incredibly powerful, and why it ultimately breaks.
Where AI Shines: The UI Bulldozer
Modern AI coding agents are exceptional at isolated, stateless tasks. When I asked the agent to build the React components for Generations of Doom, it acted like a high-speed bulldozer. It cleared the plot, poured the concrete, and built the house.
It successfully wired up the drag-and-drop card logic, styled the hover states, and built a beautiful, tactile interface. If you need to quickly visualize an idea or generate placeholder UI components so you can test if your core loop is actually fun, there has never been a better time to be a developer.
The “Memory Wall” and Context Decay
But games are not static websites. A video game is a highly volatile ecosystem where the physics, the inventory, the UI, and the enemy spawner all have to mutate and talk to each other in the exact same millisecond.
This is where AI hits the Memory Wall. No matter what tier of AI you use, context windows are basically short-term memory. AI companies love to advertise massive 2-million-token context windows, but they don’t tell you about Context Decay (or “Context Rot”).
When you feed an entire game’s codebase into an AI, the model tries to pay attention to all of it equally. Once the game logic in Generations of Doom got too complex—linking the card-draw probability matrix to the base’s damage state—the agent simply couldn’t hold the architecture in its head. It started dropping plates. It forgot variables. It hallucinated imports that didn’t exist. It would fix a bug in the card renderer, and in the process, completely delete the logic for the end-turn button.
The AI Frankenstein Trap
I quickly reached the tipping point where I was spending more time fixing the AI’s amnesia and reverse-engineering its spaghetti code than actually designing the game.
Relying purely on AI to write your core game loop is exactly like falling into the Fiverr Frankenstein trap. If you don’t personally understand how the underlying architecture talks to itself, your game becomes a black box. The moment the AI hallucinates a breaking change, you are paralyzed because you don’t know how to manually patch the logic.
Into the Prototyping Vault
So, Generations of Doom is going into the Vault. The prototype is dead, but the experiment was a massive success.
Because we operate on the Indie Flywheel model, discarded prototypes are never a waste of time; they are resources. The UI components the AI bulldozed for me are genuinely beautiful, and I will be harvesting that clean, isolated React code to use in a future tactical RPG.
AI is an incredible tool for prototyping, but it cannot be your lead engineer. You cannot outsource cohesion. For now, the experiment is over, and I am heading back to manually writing the zero-allocation physics engine for Divine Orbit.
