AI Generated Game: What You Actually Get, and What You Still Have to Fix

Short answer: an AI generated game is not one output, it is a queue of outputs, and the queue is where the money and the evenings go. The first round hands you a working core loop plus placeholder everything else — roughly the part of a game that contains no decisions. Every round after that pays for the interactions between systems rather than for the systems themselves, which is why the last third of the work costs more per unit than the first two thirds. A build with nine systems you can state as numbers converges in two to three rounds. The same nine systems left as adjectives take six to nine rounds and usually get abandoned at round four, not because the tool failed but because nobody budgeted the queue.

What follows is the count of what one round actually delivers, the arithmetic that predicts how many rounds you will need, the three cost lines almost nobody writes down, and the rule for deciding whether to patch a build or throw it back.

What one round actually hands you

A round is one generate-and-play cycle. On a first round, across the browser generators and the model-backed ones alike, the delivery is remarkably consistent in shape.

Read that table as two columns, not nine rows. Everything in the top half is a mechanism, and mechanisms are what a generator is genuinely good at. Everything in the bottom half is a decision — how fast, how many, how long, what survives a reload — and a decision you did not make gets replaced by the safest default available. The defaults are not random. They are chosen to be inoffensive, which is why they produce a game that runs perfectly and is boring in ninety seconds.

This is the honest version of "what you get": you get a demonstration that the loop is possible, plus a to-do list of decisions, plus a small pile of art you will mostly replace. You do not get a game. You get the cheapest possible proof that a game could exist.

If the tool you are using is the sentence-to-game kind — one sentence in, a 2D arcade game out, no model in the loop, no account, no credits — then that table shrinks in a useful way. You get rows one, two, three and nine in about four seconds, and you get them for free, and it does not pretend to give you the rest. That is not a lesser product, it is a different instrument: it answers "is this loop fun" before you spend a single round answering "can this loop be finished." Use it in that order and you will save most of the budget below.

The arithmetic of rounds

You can predict your round count before you start, from one number: how many systems in your prompt you cannot state as a quantity.

Call that number U, for underspecified. Then:

rounds  ≈ 1 + 0.55 × U      (cap at 8)
minutes ≈ rounds × (15 + 4 × U)

Why that shape. The first round is nearly free in effort because the model writes what you asked for, in one pass, without needing to reconcile anything. Each unspecified system then costs one corrective round, because you cannot fix a default you never defined — you have to define it, regenerate, and check that the definition did not contradict an earlier one. The 0.55 is the interaction term: slightly more than half of those corrections collide with a system you already fixed, and collisions need their own round. That is why cost grows faster than the length of your feature list.

A worked example, because the table is abstract until it is not. A 2D arena shooter with nine systems: movement, aiming, enemy spawn, enemy movement, weapon fire rate, health and damage, wave escalation, score and combo, pause and restart. You stated movement speed, fire rate, damage, wave interval and player health as numbers. That is five specified out of nine, so U is four, so you should expect three rounds and about ninety minutes.

Expect the ninety minutes to become three hours, and the difference is the next section. Also note what the formula does to a per-generation price: if your tool charges credits per generation, rounds is your bill. Nine systems at U equals four is three generations. The same nine systems with no numbers in the prompt is five or six, and the sixth one is the one where you start regenerating the same thing hoping for a different result.

Three cost lines nobody budgets

The formula above counts rounds. It does not count the three things that turn a ninety-minute build into an afternoon, and all three are invisible until you are inside them.

1. The cascade. Fixing one system breaks two you already fixed, because the systems share numbers. Raise enemy speed and the spawn interval is now wrong. Raise damage and the health value is now wrong. A cascade round costs exactly what a productive round costs and produces no new feature, so it feels like nothing happened while the clock runs. Track it as a ratio — cascade rounds divided by total rounds. Under 0.25 is normal. Over 0.4 means your systems are coupled through numbers you never declared, and more patching will raise the ratio rather than lower it.

2. The art re-roll. Generated sprites do not share a palette, a line weight or a light direction, and the drift is not visible on sprite two. It is visible on sprite six, when you have a set that reads as six games. Re-rolling for coherence takes five to eight passes in most builds and about forty-five minutes, and no amount of prompting removes it entirely — you are asking for consistency across separate generations, which is the one thing a per-image pipeline cannot guarantee. Budget it as a fixed line, not as a surprise.

3. The second-hour cliff. Minutes zero to sixty feel productive because every round adds something visible. Minutes sixty to a hundred and twenty are where the loop is proven, the remaining work is all numbers and edge cases, and nothing new appears on screen for an hour. This is where builds die, and they die of discouragement rather than of difficulty. The countermeasure is scheduling a visible deliverable at minute ninety — one complete session with a start, a loss, a win and a retry — so the flat hour afterwards has a target instead of a vibe.

Add those three to the formula and the honest budget for that arena shooter is roughly: three rounds of generation, one cascade round, forty-five minutes of art, thirty minutes of acceptance, about three and a half hours wall clock. That is the real price of "an AI generated game," and it is worth knowing before you start rather than at hour three.

A note on the numbers in this article: the minutes are budget lines computed from the formula, not survey averages, and the credit cost is whatever your tool charges multiplied by your round count. After your first build, replace every figure here with your own log. The formula is the part that transfers.

Patch or regenerate: the rule that saves the most rounds

The expensive mistake is not a bad generation. It is patching a build whose structure is wrong, for four rounds, before admitting it. These six situations cover most of the decisions.

Two rules make that table usable in the moment.

The twenty-minute rule. If you cannot point at the specific place in the build where the behaviour goes wrong within twenty minutes, you are not debugging, you are browsing. Stop and regenerate with a tighter prompt. Browsing generated code has a terrible hit rate because the code is plausible everywhere and correct only sometimes.

The two-round rule. Any single bug that survives two patch attempts gets a regenerate, no exceptions. The second failed patch is the signal: it means your description of the fix and the model's model of the system have diverged, and no third description will reconcile them.

Regenerating feels like losing progress. It is not — the prompt you regenerate with is strictly better than the one you started with, because you now know which numbers matter. That is the asset you are actually accumulating across rounds, and it is why round four with a good prompt beats round two with a vague one.

The log you fill while building

This is the part that turns the arithmetic into something you can act on. Six columns, one row per round, including the ninety-second ones you are tempted to skip.

Two numbers at the end tell you whether the build is healthy: total rounds, and cascade ratio. Three rounds and 0.0 is a build that converged. Seven rounds and 0.45 is a build that is fighting you, and the correct move is a smaller game rather than an eighth round.

The "what changed" column is the one people skip and the one that pays. By round four you will not remember which numbers you already declared, and you will re-declare one of them slightly differently, which is a self-inflicted cascade. The log is cheaper than the memory.

The abandon test

Run this when the build is playable but you are not sure it is finishable. Pass or fail, no partial credit.

1. You can go from launch to a loss to a retry without opening the editor. Fail here means the game is not a game yet, regardless of how it looks.
2. The core loop holds three minutes without a new mechanic being added.
3. Your cascade ratio is under 0.4.
4. Every system you kept has a number you can say out loud.
5. You would play it one more time with nobody watching.

Three or more fails and the honest move is to cut the game down — one mechanic, one hazard, one win condition — and spend two rounds making that small thing good. Five passes and you are finished, and finishing is the only outcome that matters, because an abandoned build teaches you nothing about the next one except that you abandoned it.

What the queue is really telling you

The thing you get from a generator is the loop, for free, in one round. The thing you pay for is the decisions, at full price, one round at a time. That split is stable across tools and across model generations, and it is the reason "better AI" has not made builds shorter — better models produce more plausible defaults, and plausible defaults are exactly what you have to replace.

So the budget is not a tool choice. It is a scope choice plus a log. Fewer systems, each stated as a number, and a running record of which round bought what. Nine systems with numbers is a two-round build and a finished game. Nine systems without numbers is a six-round build and a folder you stop opening.

Count the rounds before you start. It is the only part of this you can control, and it decides everything else.