The small games are about to multiply

Three games crossed my feed in the same month. Each one sells itself in a single sentence:

• Steal a face. Study a life. Survive the conversation. (Legion Was Here)
• Open large packs of cards. (Catch A Pack)
• A turn-based brawler where teeth are your health and your money. (Tooth for Tooth)

None of them is a studio production in the usual sense. Legion Was Here is one person. Catch A Pack is two. Tooth for Tooth ships under a studio name, Outlane, with one developer’s name on its website. Catch A Pack is not even out yet. Its store page says 2027 and has already sold me the premise.

I have not opened their files. From the screenshots and trailers, which is all I have, none of them needs a skeletal rig or sixty hand-drawn frames of a sword swing. Each one reads as a pile of flat drawings moved by code.

I shipped a game like that for iPhone. Strike a Line is one sentence: You draw the path, Milo runs it. The sentence took five minutes. The physics and the artwork took a month, most of it spent staring at coordinate planes and asking why a cartoon runner was walking through a wooden crate.

That month is the part getting cheaper. Not free. Cheaper. Here is the recipe as I understand it, including which parts I would hand to a model and which I would not.

The sentence is the file list

A small game survives if its core verb fits in one sentence. If it takes three paragraphs to explain what the player’s hands do, it is not a small game. It is a theme looking for an excuse.

The sentence is not marketing copy. The sentence is the asset manifest. Read it literally and it tells you which folders to make:

• Steal a face needs noses, eyes, and jaws that fit the same skull.
• Open large packs needs card frames, foil wrappers, and confetti.
• Teeth are your health and your money needs mouths, loose teeth, and fists.

Anything the sentence does not ask for gets deleted before the first line of code. No inventory screen in a game about punching. No skill tree in a game about opening packs. The sentence has to be mean enough to throw away ninety percent of game design, so the remaining ten percent ships.

Ask for parts, not scenes

The common mistake with image models is asking for a scene.

Ask a model for a screenshot of my game and it returns a painting: a health bar fused into the background, a button lettered in gibberish, and a hero whose hands are melting. Code cannot update a painted number. A baked-in health bar is a picture of a health bar.

The ask has to be boring on purpose:

• One object per file.
• A flat background, or a transparent PNG.
• A clean ink outline.
• A small, fixed palette.
• No text in the image. Ever.

You are not ordering a character. You are ordering a paper doll.

The store page promises more than 900 million combinations. That sounds like a triple-A asset budget. Structurally, it is a few folders of parts and a fixed draw order: head, eyes, nose, mouth, hair. Multiplication does the rest. For parts to combine at all, every nose has to land on the same anchor at the same scale. That is the real spec, and it is dull.

Here is the reversal. The same store page says the game was made entirely solo and “without recourse to AI.” The best example of the cheap-folder recipe paid full price for its folder, in one person’s hours. The technique is old. What changes is the price of the parts. A model can now draft fifty noses before lunch. Whether any of them belongs on the skull is still your problem.

Scenes work the same way. Before the conversation, you study the life you are about to borrow:

None of this needs a 3D desk. The briefing can be a flat image. So can the circus poster. The hand covered in notes can be one drawing that slides in and out. The dialogue choices look like live text, which is why they can change. The scene feels alive because flat pieces are layered in a clean order.

Swap poses, skip animation

Frame-by-frame walk cycles and rigged 2D skeletons are how solo developers go missing. The small-game version skips animation. An action is a pose swap.

Tooth for Tooth fights in turns:

I would build that punch from three files:

1. idle.png
2. hit.png
3. recover.png

When the player taps attack:

• Swap to hit.png.
• Knock the opponent back six pixels.
• Shake the camera.
• Play a crunch.
• After 150 milliseconds, swap back to idle.png.

The brain supplies the motion it did not see. Two sharp drawings and a shake land harder than twelve floaty in-betweens.

Between fights, the same rule holds:

A portrait, two panels of text, and a tray of teeth. Health is a count. The count is drawn as teeth. The whole economy fits in one bowl.

Keep the motion in code

If none of the drawings move, something has to stop the game from feeling like a slide deck. That something is the tween.

A tween redraws nothing. It changes the transform of an existing image over time:

• Position: cards sliding onto the table.
• Scale: a button squashing under a press.
• Rotation: a pack wobbling before it bursts.
• Opacity: a damage number fading out.

Catch A Pack, by Dy Seath and Blazar, is built on packs:

The pack does not need a tearing animation. If I were building it: scale it up 15%, shake it along the X axis for 120 milliseconds, let an easeOutBack curve overshoot, then slide four cards out along their paths. Those numbers are mine, not theirs. You find your own the same way, by changing them until they stop being wrong.

Juice is the tactile lie that makes clicking a PNG feel like a hit:

• Squash and stretch: scale to (1.1, 0.9) on click, then snap back.
• Particles: a handful of yellow circles thrown from the cursor.
• Floating numbers: text that drifts up and fades to zero.
• Screen shake: move the camera by random values between -3 and 3 pixels for 80 milliseconds.

All of it lives in code. Juice does not need an artist. It needs an inspector panel and an afternoon of tuning milliseconds until your own thumb believes the impact.

Give the model the plumbing

The popular picture of AI in game development is typing make me a roguelike and watching one appear. What appears is sludge.

Where I would let a model earn its keep is the plumbing nobody wants to write twice:

• State machines: scene changes and turn order (WAITING_FOR_INPUT → RESOLVING_ACTION → CHECK_HEALTH → CHECK_WIN_LOSS).
• Save files: a JSON schema for game state, local storage, and the migration for the day the schema changes.
• Balance runs: a script that plays 50,000 headless matches to find the tooth or card that breaks the math.
• Localization tables: string files that survive translation without blowing out the button widths.

Tooth for Tooth is open about its own use. The Steam page says: “Our team used generative AI tools to assist with artwork, animation, audio, text, localization, and marketing materials. We directed the creative process and selected, edited, and incorporated the resulting material into the game and its promotional content.” The game ships in sixteen languages.

That disclosure goes well past plumbing. It includes the art. Its last sentence is still the job description for everyone using these tools: direct, select, edit. The model drafts. Someone still has to decide.

Delete almost everything

Generating five hundred sprites takes an hour. The craft is throwing away four hundred and seventy of them.

Models have no sense of a set. Ask for twelve icons and three come back with thick ink outlines, four look like watercolor, and two have wandered in from another perspective.

Get attached to an asset because it looks good alone and the game turns into a sticker book. The test is the neighbors:

• Line weight: does the outline match the rest of the screen?
• Palette: does it share the light and color of what sits next to it?
• Readability: can you tell what it is at the size of a thumb?

The loop is short:

1. Generate twenty candidates.
2. Drop them into the running game, not a gallery.
3. Compare them against what is already on screen.
4. Keep the two that disappear into the set. Delete the rest.
5. Repeat.

My own table

I tried the recipe on a bigger plate. Lazy Susan: Spin the Chef is a roguelike deckbuilder at a rotating dinner table, built in Godot. The sentence: the Chef tries to kill me with a pepper, and I can send it back.

The first commit is dated October 2. By October 28 the repository has 341 commits, and 332 of them end with a Claude co-author line: 283 Opus, 45 Sonnet, 4 Haiku. On October 9 the log shows 140 commits. I did not type 140 commit messages.

The division of labor, as it actually ran: the pictures came from image models, Codex’s image generation steered toward 31 reference images I made in ChatGPT. Claude Code was the engineer. It wrote the combat, the save files, online tables on Steam, the bots that play the game against itself, and a screen matrix that renders every screen in five languages at four screen sizes and checks whether the text fits. Four card texts failed that check and were shortened to fit at 16 pixels. It also scripted a 44-second trailer out of the real game, cut so every edit lands on a bar of the music.

So the plumbing section above undersells it. The model did not stop at plumbing. What it did not do was decide. The balance changes in the log wait for a person: “provisional balance (HP and Last Orders await sign-off)”, “Calibration round 2 applied (your sign-off).” The bots can tell me a setup wins too often. They cannot tell me whether it is fun to lose to.

The art is where the recipe bit me. Paper dolls and pose swaps work. The game has 88 character poses, a gloat, a defeat, an eager lean for each guest, swapped on cue. But this post tells you to delete 470 sprites out of every 500. My rejected folder holds 18 files.

On October 27 I had all 434 images in the game audited for the habits that give AI art away. The report was not kind. Seven of 18 characters share one gaunt, long-nosed face: “one model’s default villain in different costumes.” Every cut-out wears the same heavy sticker outline. The gold glints. Squiggles stand in for writing on the tickets. One achievement shows a modern burger and fries in a Belle Époque restaurant. Nobody had deleted it. It had a frame.

Some fixes had already happened, one at a time. The Cloche was redrawn as a glass bell jar because it read as the Lid. Second Stomach came back with the figure’s head cropped off and was redrawn as a let-out belt and clean plates. The rest is a finishing pass and a stricter set of prompt rules, still sitting on a branch.

The month got cheaper. The taste did not. I had a faster engineer than I could have hired and the same eyes I started with, and the eyes were the slow part.

The flood

For years, game development’s graveyard was full of good one-sentence ideas. Someone would have a ridiculous premise, your teeth are your wallet or forge a face from a dossier, then count three hundred matching drawings and six months of UI work, and close the notebook. The idea was free. The folder was not.

The folder is getting cheaper. The recipe fits on an index card:

1. One mean sentence.
2. A folder of flat parts: paper dolls and pose swaps.
3. Tweens for motion.
4. A model for drafts and plumbing.
5. A delete key for coherence.

Most of what comes out of that recipe will be bad. Free sketchbooks produce a lot of scribbles. Somewhere in the pile will be games that are strange, sharp, and too small to have justified a budget, finished and sitting on a store page next to everything else.

The sentences were always there. The folder was the toll. Geoffroy Monde paid his in full, by himself. Everyone else is about to get a discount.