A November 2026 r/gamedev thread was titled "AI gave us 40 playable concepts and zero fun ones" — and the number is the whole problem. When generation costs a prompt, you don't get a shortlist; you get a slush pile. You evaluate AI game concepts by triage, not by rereading: four gates — honest pull, a one-sentence core, weekend scope, and differentiation — cut 40 concepts down to two or three in about an hour, and only the survivor earns a greybox prototype. The filter has to be you, on purpose: research on generative AI shows it raises the quality of each individual idea while making the pile measurably more samey, so selection — not generation — is now the skill that decides whether any of it ships.
A disclosure before the filtering starts: this blog belongs to Egmatic, a pre-alpha AI-native 2D game builder, so the generate-filter-build loop is literally our product thesis. We have a stake in this working, and we'll just as plainly mark where the current state of the art is weak. Nothing below requires our tool or any tool — the process runs on a spreadsheet and an afternoon. External findings are named with dates and sources; the four-gate triage itself is our editorial synthesis, built from watching developers run this loop since AI concept lists became normal in 2024.
This article is the stage between generating and building, and it deliberately skips its neighbors. Which tool to prototype in is covered by the prototyping tools by use case guide. What to delegate to an AI assistant once you're building is its own guide. Testing the one idea that survives is the job of the rapid idea-testing playbook. And if you're upstream of all of it, still choosing an engine, start with how to choose a 2D game engine.
Quick answer
Run the list through four gates, in order, and let every gate kill rather than improve. Pull: would you play this for an hour on Friday — not "could this be built," would you play it. Core sentence: can the concept state its own fun in one line — "this game works if ___ is fun." Weekend scope: could one person greybox that core loop in a weekend. Differentiation: does the sentence narrow the field, or could it sit on twenty already-shipped games unchanged.
| Stage | Input | What you actually do | Typical survivors |
|---|---|---|---|
| Gate 1 — pull | 40 raw concepts | Read titles and one-line pitches; kill anything you wouldn't play | 10–15 |
| Gate 2 — core sentence | Gate 1 survivors | Fill in "works if ___ is fun" per concept; kill what can't | 5–8 |
| Gate 3 — weekend scope | Gate 2 survivors | Estimate the greybox for the core loop; kill multi-system premises | 3–5 |
| Gate 4 — differentiation | Gate 3 survivors | Collision-test the sentence against shipped games; twist or kill | 2–3 |
| Prototype | The shortlist | Pick exactly one; greybox it and put it in front of players | 1 |
The design choice that matters is the ordering: the gates run cheapest first. Gate 1 costs a glance at a title; Gate 3 costs real estimation effort. Killing on a glance before investing estimation is how a 40-item list takes an hour instead of a week — and reading deeply before glancing broadly is the single most common way these lists eat whole evenings.
Why the pile reads as zero fun
There are two reasons, one measured and one older than AI.
The measured one: in July 2024, Science Advances published an experiment by Anil Doshi and Oliver Hauser in which writers produced short stories with or without access to generative AI ideas. Access helped individually — stories written with AI ideas were rated more creative, better written, and more enjoyable, with the largest gains for the less creative writers. But the collective output converged: writers who used even a single AI idea produced stories 10.7% more similar to each other than the no-AI group's. Apply that to your concept list and "zero fun ones" stops being mysterious. A language model asked for game concepts returns high-probability combinations of everything already pitched in its training data — each item individually plausible, the pile as a whole a set of variations on the median idea. You didn't get 40 ideas; you got roughly one idea, 40 times, wearing different hats.
The older one: fun was never a property of a concept sheet in the first place. Raph Koster's A Theory of Fun (2004) argues that fun is the feeling of learning a still-surprising pattern — which exists in the playing, not in the premise. No document, human- or AI-written, can tell you whether a loop will be fun; that is what the greybox is for. An honest evaluation process therefore doesn't try to find "the fun one" by reading. It finds the cheapest-to-test candidates with the strongest differentiators, and spends its remaining budget on playable probes instead of prose.
One more trap worth naming: the volume itself feels like progress. A 2025 randomized trial by METR found that experienced developers using AI tools finished their tasks 19% slower while believing they were faster — the feeling of momentum and the momentum are different things. Forty concepts in an evening is the same illusion at the ideation stage: generation is not movement, and the filter is where movement starts.
Gate 1 — The pull test
Read only the titles and one-line pitches. For each, one question: would I play this for an hour on Friday night? Not "is this clever," not "could this sell," not "would this make a good portfolio piece." Would you play it.
This gate exists because AI lists are optimized for plausibility, and plausibility impersonates appeal at title distance. A concept can be coherent, market-shaped, mechanically reasonable — and something you would never actually open. Prestige concepts die here: ideas you admire but wouldn't play are the most expensive kind to prototype, because your motivation runs out exactly when the greybox needs iterating.
The rule that keeps it honest: if you hesitate, kill. You are not judging the concept's quality — you couldn't, from a line — you are sampling your own reaction, which is the one signal on the table that the model doesn't have. As of 2026 no model knows what you'd enjoy playing. That's not a limitation to work around; it's the entire reason this gate works.
Gate 2 — The one-sentence core
Each survivor now writes one sentence: this game works if ___ is fun. The grappling-hook movement. The drafting tension. The spatial logic of the puzzle. If the blank fills with a noun — zombies, ocean, detective, cyberpunk — you have a theme, not a core, and it goes back or out.
AI concept lists systematically fail this gate in a specific way: they sell premises. A generated pitch leads with setting, twist, and fantasy, because that's what concept-shaped text looks like in the training data. Interaction — what the player repeatedly does — is usually buried or absent. Forcing the sentence drags it to the surface or exposes its absence.
The sentence also becomes the prototype's contract. When the survivor goes on to a greybox, this is exactly what gets built and tested, in the rapid idea-testing playbook — nothing more. A concept that can't state its core can't scope its prototype.
Gate 3 — The weekend-scope check
Feasibility, asked at concept scale: could one person greybox this core loop in a weekend? Not the game — the core loop, in plain rectangles, playable in two minutes.
Concepts that need systems before they can show fun fail here, honestly rather than tragically: an economy sim needs a working market before any decision feels meaningful; a narrative game needs arcs before tension exists; anything multiplayer needs a netcode layer before there is anyone to play with. These aren't bad ideas — they're untestable at the scale you can afford, which for a solo developer is the same thing, this quarter.
The greybox discipline itself — one mechanic, placeholder everything, no tutorial text — is covered in the mechanics-validation guide; this gate just decides whether that discipline can be applied to this concept before your enthusiasm expires. A weekend is the honest ceiling because it's the unit of sustained attention most solo developers actually have.
Gate 4 — Differentiation, not originality
The last gate asks not "is this new" but "is this distinguishable from the median thing its own prompt would produce." Doshi and Hauser's convergence result, applied at the level of your list: the pile's center of gravity is the average idea, and any individual concept is probably near that center unless something pushes it off.
The practical test is a collision check. Take the core sentence from Gate 2 and ask whether it narrows the field: could this exact sentence sit on twenty already-shipped games without being wrong about any of them? If yes, the concept is the average idea again, and you have two honest moves. Twist one verb — change what the player does, not the skin it's wearing; "grappling-hook movement, but the hook is currency you spend" is a twist, "grappling hooks, but in space" is a reskin. Or kill it, and let the pile shrink.
Originality by itself is explicitly not the goal — that's the mirror error this gate exists to prevent. A familiar loop with one genuinely fresh verb beats an original-sounding premise nobody can play. Order matters: pull and scope came first because a distinguishable concept you'd never play is still somebody else's average, just with better marketing.
What the survivors get
Two things only. A shortlist of at most three, and a prototype queue of exactly one — the one you'd most want to play, not the one that scored most elaborately. The greybox gets built serially, played by you until the novelty fades, then handed to three to five other people, with kill criteria written down before the first rectangle is placed. That entire next stage is the testing playbook's job, not this one's.
The survivors you didn't pick get one written line each — what their best gate performance was, and which gate eventually killed them if re-tested — and then they stay closed. That log is a graveyard with causes, not a backlog. Revisiting an idea next quarter means re-running it through the gates against fresh competition, not reopening a filed decision. Forty open options is anxiety with a filename; three closed lines and one active prototype is a plan.
Five mistakes worth avoiding
Asking the model to rank its own output. The most natural move in the world — "which of these forty is best?" — works against you, measurably. A NeurIPS 2024 paper by Panickssery, Bowman, and Joshi found that LLM evaluators rate their own generations higher — even when human raters prefer the alternative texts — and that the bias grows stronger the better a model recognizes its own output. The generator can't want anything, including your game's success. Use it for clustering, overlap summaries, and rewording pitches; keep the verdict on your side of the table.
Falling for the premise. If your excitement about a concept is about its world — the setting, the twist, the fantasy of it — rather than the verb, the greybox will come out hollow. Premises are cheap to generate and expensive to build; verbs are where the fun lives or doesn't.
Prototyping the shortlist in parallel. Three greyboxes built at 30% attention each validate nothing and burn the month. One concept, one weekend, one honest verdict — then, if it died cleanly, the next one. Serial beats parallel everywhere in this pipeline because attention, not tooling, is the bottleneck.
Keeping the pile as a backlog. An untouched list of 40 "options" doesn't create optionality; it creates low-grade guilt and a bias toward stale ideas. Log, close, regenerate later. A fresh prompt run next quarter produces better-fitted candidates than a nine-month-old list anyway — the models move, and so should you.
Filtering for novelty alone. The mirror error of Gate 4: chasing the concept that sounds unlike anything and forgetting that unplayable originality is still unplayable. The gates are ordered the way they are — pull and scope before differentiation — precisely because a novel idea you wouldn't enjoy building is a dead end with better branding.
Where Egmatic fits
Notice what this whole article assumes: that generating concepts is the cheap half now, and that the expensive half — taste, filtering, the decision to commit a weekend — runs through a human. That assumption is also our product thesis. We're building Egmatic as an AI-native 2D game editor where you direct — what the game is, what the core loop is, what changes after playtest — and the AI executes the drafts inside the project, with every exported file staying yours in formats you can leave with. The loop we're aiming at is this article compressed: a concept survives your filter in the morning, and faces players as a greybox the same week, without an engine-learning tax in between.
Honesty clause, same as ever: Egmatic is pre-alpha. Early access today means build news a few times a year, not promises of magic. But the division of labor this article describes — the machine generates, you decide — is exactly the line we're building on, because it's the line the evidence keeps drawing.
If that's the loop you want to watch mature:
Fact-check notes
Checked November 19, 2026, against live sources:
- Doshi & Hauser, "Generative AI enhances individual creativity but reduces the collective diversity of novel content," Science Advances 10(28), July 2024: writers with access to generative AI ideas produced stories rated more creative, better written, and more enjoyable, with the largest gains for less creative writers; writers who used one AI idea showed a 10.7% increase in pairwise similarity versus the no-AI group. science.org/doi/10.1126/sciadv.adn5290, verified November 19, 2026.
- Panickssery, Bowman, and Joshi, "LLM Evaluators Recognize and Favor Their Own Generations," NeurIPS 2024 (arXiv:2404.13076): LLM evaluators rate their own outputs higher than human raters do, even when humans prefer other texts; fine-tuning experiments showed the self-preference bias scales with self-recognition capability. arxiv.org/abs/2404.13076, verified November 19, 2026.
- METR 2025 randomized controlled trial: experienced open-source developers given AI tools completed tasks 19% slower while self-assessing as faster; previously verified for our October 2026 coverage of building with AI assistants and consistent with it here.
- Raph Koster, A Theory of Fun for Game Design (2004): the paraphrased thesis — fun as the mental sensation of learning patterns, which lives in play rather than in description — is the book's core argument; used here as theory context, not as a study.
- Valve's AI Content on Steam policy: disclosure obligations live since January 2024; the January 2026 revision narrows disclosure to AI-generated material players see or hear in the game, on the store page, or in marketing, treating purely internal development use as out of scope. Per our standing coverage of AI content on Steam, re-checked with this article.
- The "40 playable concepts, zero fun ones" thread: a verbatim r/gamedev thread title from November 2026, recorded in our developer-community sweeps (window of November 4–11, 2026). Quoted as the motivating community observation; deliberately not linked, since the thread is the seed of the question, not evidence for any claim in the answer.
- The four-gate triage, the funnel table, the graveyard-not-backlog rule, and the ordering logic (cheapest kills first) are editorial synthesis — our own — and are labeled as such where they appear.