A complete mini-game now costs $10 to build. Here's the whole guide:

Cover image

I built a playable 3D game last week for less than the price of two coffees.

not a demo. not a gray box with a cube in it. a full scene: lighting, physics, hit reactions, a menu that works.

the whole thing cost about $10 in tokens.

that number is the reason this article exists. for twenty years the wall around game development was money and headcount. Rockstar spent seven years, 2,000 developers and $500,000,000 on Red Dead Redemption 2. that wall didn't come down because someone got generous. it came down because the price of building collapsed.

so instead of another "AI is amazing" post, here's the thing nobody publishes: the actual price list.

the price list

every number below is what it actually costs to build the thing with Kimi K3, end to end, in tokens:

> regular vibe coding: $0.08-0.10 a polished landing page: $0.10-0.30 a dashboard or an interactive tool: $0.30-1 a full-stack prototype: $1-3 an interactive 3D experience: $1-5 a complete mini-game: $10 a more advanced game: $10-30+

now the line that reframes the whole table: Fable 5 and GPT-5.6 Sol cost roughly 5x more for the same work.

that's the entire story of this launch in one comparison. not "a Chinese model caught up." a model that matches Fable-level results and charges Sonnet-level prices.

five times cheaper does not mean you save money. it means you run five times more experiments with the same budget, and experiments are the only thing that produces a hit.

what K3 actually is

before the plays, the spec, because it explains why the prices look like that:

> 2.8 trillion parameters. the biggest open-source model ever shipped 1,000,000 token context. your whole codebase in one pass, not a folder at a time native multimodality. it sees images and video, it doesn't read a description of them SOTA on HLE with tools, SWE-Bench Pro, SWE-bench Multilingual, BrowseComp, Toolathlon, CharXiv and MathVision with Python outperforms Claude Opus 4.8 and GPT-5.6 Sol, on par with Fable 5 built for long-horizon coding: large codebases, tool use, recursive self-improvement

— "Kimi is the best at frontend development"

the two specs that matter most for what follows are the boring ones. the 1M context is why K3 can hold an entire game project in its head instead of forgetting the physics file while it writes the menu. long-horizon coding is why it can run for hours on one goal instead of producing a beautiful fragment and losing the thread.

PLAY 1: the $10 game

start with the headline number, because it's the one people don't believe.

a complete mini-game: $10. an advanced one with real systems: $10-30+.

for context, the cheapest human quote you'll get for a simple browser game is four figures and three weeks.

what people have already built at this price point: a WebGPU VFX combat arena, a browser-based 3D city traversal in a SpiderPunk style, an MMORPG prototype, a racing game, an FPS, a 3D space shooter, an Animal Crossing style prop interaction system, even a working 3D GBA emulator.

→ the prompt that gets you a real scene instead of a gray box:

Build a playable browser game in a single HTML file. No frameworks,
no build step, no CDN. It must run by double-clicking the file offline.

THE GAME: [one sentence: what the player does and what makes it fun]

MUST HAVE:
1. Controls that feel right: WASD + mouse, no input lag, no stuck keys
2. Real hit feedback: impact flash, knockback, a sound cue, screen shake
3. Lighting with shadows, not flat ambient
4. A win state and a lose state, both reachable in under 3 minutes
5. A menu that starts, pauses and restarts without reloading

DONE MEANS, check every box yourself before telling me it's finished:
- [ ] opens cold and plays with zero console errors
- [ ] the loop is completable in under 3 minutes
- [ ] hit reactions are visible in the first 10 seconds of play
- [ ] framerate stays smooth with 20+ entities on screen

Work through it end to end. Announce each step before you do it.
Then run the checklist yourself and show me the results.

the math:

> one complete mini-game: $10 ten variations of the same idea, testing which one is fun: $100 the same ten variations from a freelance dev: five figures and two months the point isn't the savings. it's that ten tries used to be impossible, and one try is how you make something mediocre

mistake to avoid: do not ask for "a game." ask for one loop that has to be completable in three minutes. scope is the whole difference between a $10 game and $30 of confident garbage.

PLAY 2: the $0.30 landing page and the $1 dashboard

games are the demo. this is the part that pays rent.

> a polished landing page: $0.10-0.30 a dashboard or interactive tool: $0.30-1 a full-stack prototype: $1-3

freelancers charge $500-2,000 for the landing page. agencies charge $5,000 for the dashboard. the work itself now costs less than a snack, and the only scarce input left is knowing what to build.

→ the landing page prompt that doesn't produce template slop:

Build a landing page for [product] as one self-contained HTML file.
Inline CSS and JS. No frameworks, no CDN, works offline.

AUDIENCE: [who] · THEY CURRENTLY: [what they do instead] · THE PROMISE: [outcome]

STRUCTURE:
1. Hero: one headline naming the pain, one line naming the outcome, one CTA
2. Three proof blocks, each with a concrete number, not an adjective
3. An objection section: the three reasons they don't buy, answered plainly
4. A closing CTA that repeats the promise in different words

DESIGN: dark, high contrast, tabular numbers, generous spacing.
No stock-photo vibes, no gradient soup, no "revolutionary" language.

Then critique your own page in five bullets and rewrite the weakest section.

that last line is worth more than the rest of the prompt. one self-critique pass costs a fraction of a cent and removes most of the generic feel.

the math on a real workflow:

> test 5 landing pages against each other: $1.50 the same test with an agency: one month and $10,000 at 5x the price on other frontier models, the same test runs $7.50, which is still cheap but it's the difference between testing every idea and rationing them

PLAY 3: interactive 3D, where the price gap gets absurd

interactive 3D experiences: $1-5.

this is the category that used to require a specialist. shaders, glossiness, real shadows, sound design tied to physics. a 3D dev bills $80-150/hour, and "make the metal look wet" is a half-day conversation.

→ the prompt for a 3D scene that looks expensive:

Build an interactive 3D scene in one HTML file using WebGL/WebGPU.
No frameworks, no CDN, runs offline by double-clicking.

THE SCENE: [what it is and what the user can do in it]

MAKE IT LOOK EXPENSIVE:
1. Physically-based materials: real roughness, metalness, fresnel on edges
2. Shadows that move with the light source, not baked ambient occlusion fakery
3. Micro-detail: dust, scratches, subtle normal variation, no clean plastic surfaces
4. Camera: slight inertia, no snapping, and a subtle depth of field
5. One sound cue tied to a physical event, not background music

CONSTRAINT: it must hold 60fps on a laptop with integrated graphics.
Cut visual features before you cut framerate.

Verify by listing what you cut to hold framerate and why.

the math:

> one interactive 3D experience: $1-5 a 3D freelancer for the same result: $500-1,500 and a week of revisions five versions with different art directions: $25 and an afternoon

the part that actually changes your workflow

here's what the price list does to how you work, and this is the real payload of the article.

when a build costs $10, you stop planning and start attempting. that sounds like a small change. it isn't.

the old loop: think for two weeks, spec it carefully, build once, pray. one shot, high stakes, and the cost of being wrong is the whole budget.

the new loop: build five, look at them, keep one. the cost of being wrong is a coffee.

> at $10 per game, a $100 budget buys ten swings instead of one at 5x the price, that same $100 buys two. and two swings is not enough to find a hit nobody's first version is the good one. the price of iteration decides whether you ever reach the good one

that's the whole argument for cheap frontier-grade tokens: not savings, but attempts.

what this does not fix

the honest section, because the price list creates a specific illusion.

cheap builds do not make you a game designer. the model can generate a combat arena in an hour, and it will happily generate a boring one at the same price. taste is still yours, and taste is still the bottleneck.

cheap builds also do not make a business. a $10 game with no audience is a $10 game nobody plays. distribution has not gotten one cent cheaper this year, and it's the only part of this stack that money still can't shortcut.

and scope discipline matters more than ever. an unbounded prompt burns $30 producing something confident and useless. the $10 number assumes you constrain the thing: one loop, one checklist, one definition of done.

the tool got cheap. the judgment did not.

what to do this week

pick one, and pick the smallest version of it:

> day 1: the $0.30 landing page for something you already sell. compare it to the one you have day 2: the $1 dashboard for a number you check manually every week day 3: the $10 mini-game, one loop, three minutes, one mechanic that has to feel good day 4: rebuild whichever one performed best, three different ways, for the price of one lunch

total spend for the week: under $15. the same week of freelancer time: four figures.

the close

for twenty years the answer to "why don't you just build it" was money, and it was a real answer.

a complete mini-game is $10. an interactive 3D experience is $1-5. a landing page is thirty cents. the frontier-model version of the same work is five times that, and everything else is unchanged.

the wall between an idea and a playable thing used to be a studio. now it's a weekend and a price list.

the only question left is what you build with ten swings instead of one.

Bookmark this before it gets buried. If this was useful, share it with one person who needs it.