Six Dollars a Game: A 15-Second Clip Becomes a Playable Three.js Level

Thirty-one games. A thousand and thirteen fal calls. Two hundred and two dollars. That's the ledger at the bottom of the video-to-game README, and it's the most persuasive paragraph in the repo — not because the games are good, but because someone counted.
The project itself is a skill, not an app. You install it into Claude Code or Codex or Cursor, hand it a ten-to-fifteen-second gameplay clip, and it produces a playable browser level: a single index.html with Three.js and nothing else. No engine, no template, no other library. Every one of the thirty-one demo games was rebuilt from a clip that a video model generated first.
Several people have built "AI makes a game" demos this year. What makes this one worth examining is the specific claim underneath it: an agent cannot design a game's look, so stop asking it to. Let a video model do that part, then make the agent match it.
The video is the design document
Read the README's own complaint and you'll recognise it instantly if you've ever tried this:
Asked for "a game where a boy glides between flying whales", they ship grey boxes, a default sky and a camera that fights the player.
That's exactly what happens. A coding agent asked to build a scene will reach for primitives — boxes, planes, a hemisphere light — because primitives are what it can express in code. It has no opinion about composition. It has no taste about fog density. The result is technically a scene and emotionally a test level.
A video model, whatever its other flaws, is very good at exactly that missing piece: look, camera, mood, a single memorable moment. So the pipeline inverts the usual order. Video first, then code that has to match.
study_video.py turns the clip into frames, a contact sheet, a palette, and cut times. The agent then writes a spec from named frames — camera, hero, the one mechanic, the key moment, the look. Not "a forest level." Something like: low camera two metres behind the hero, cool green fog at six metres, one teal light source from the left, the mechanic is gliding.
Everything after that is matching.
Every asset comes from the video's own frames
Concept sheets with Nano Banana Pro. Clean cutouts. Image to 3D through Meshy, Tripo, or Hunyuan 3D. Rigging and animation. Sound effects and music. All logged through fal_asset.py. The README's rule is blunt: nothing drawn by hand, nothing downloaded.
That constraint is doing more work than it looks like. A human building a game from a reference will download a tree model and hope it fits. An agent with a download allowance will pull the first result from a free asset site and the art direction collapses into a collage. Forcing every asset through the same generator, seeded by the same frames, keeps the palette coherent by construction.
The look is treated as a spec rather than a polish pass: tone mapping, one grade, fog, bloom, vignette, and grain, all derived from the first scene. After every change, the agent produces a side-by-side picture of the video and the game at the same three spots.
That side-by-side is the whole methodology in one artefact. Without it, the agent optimises against its own imagination. With it, the agent optimises against a reference it can actually see.

The agent plays its own game
This is the part I didn't expect, and the part that separates the project from a demo reel.
A keyboard scenario drives the game and reads window.__game the way a player reads the screen. record_play.mjs films the result at real frame rate using Playwright. best_window.py finds the liveliest seconds of that recording. Falls, invisible walls, and dead stretches get fixed before anyone else plays.
Automated playtesting is not new. Automated playtesting where the agent then fixes what it saw, and where the evidence is a video it can inspect, is a meaningfully tighter loop. It also explains the cost: the agent runs the game dozens of times per iteration.
The bill
Let's be precise, because these numbers are the reason to read the repo at all.
Thirty-one games. 1,013 fal calls, broken down as 594 images, 194 3D models, and 290 sounds and music tracks. $202 in total. About $6 per game.
Six dollars is a strange number to hold in your head, because it's roughly the price of a coffee and roughly a thousandth of a contract artist's day rate. It's also not the real cost — the coding agent's tokens aren't in that figure, and neither is your afternoon. But it establishes something useful: the marginal cost of a small playable 3D scene is now low enough that you can throw one away.
The catch, stated plainly in the README, is that you pay fal for every asset, and the outputs are short demos rather than finished products. A six-dollar game is a vertical slice of a feeling, not a game you'd ship.
Installing it
Claude Code first, since that's the best-supported path:
claude plugin marketplace add lovisdotio/video-to-game
claude plugin install video-to-game@video-to-game
Or copy the skill folder by hand: cp -R skills/video-to-game ~/.claude/skills/.
For Codex, Cursor, Gemini CLI, Copilot and the rest:
npx skills add lovisdotio/video-to-game
The scripts need Python 3.9+, ffmpeg, Node 18+ with playwright-core, and pip install fal-client plus a FAL_KEY.
Then the prompt is one paragraph:
Turn gameplay.mp4 into a playable browser game with the video-to-game skill.
The prompt that made it is in gameplay.txt. Generate every asset with fal,
match the video's look, and show me side-by-side pairs and a recorded take
of you playing it.
If you don't have a clip, the repo ships prompts/gameplay-video-prompts.md — the rules that made the thirty-one videos rebuildable, plus every prompt used. That file is quietly the most valuable thing in the repository, because it's the part that encodes what makes a clip a good design document: readable silhouette, one mechanic, a camera that doesn't fight the player.
What this is really about
There's a version of the AI game-generation story that goes: models will eventually make games directly. Maybe. In the meantime, this project describes a division of labour that works today — video models for taste, coding agents for construction, image-to-3D for assets, and an automated playtest to close the loop.
The interesting question isn't whether six-dollar games are good. They're not, mostly. It's what happens when the same pattern gets pointed at something with a budget: a product launch page, a museum kiosk, a training simulation. The pipeline doesn't care what the level is for.
And there's a smaller, sharper lesson for anyone building agent tooling. The reason this repo works is that it made the reference inspectable. A video is something both a model and a person can look at, compare, and argue about. Give an agent a spec and it will satisfy the spec. Give it a clip and it has to match something real.
That's a better interface than a prompt. It might be the better interface for a lot of things.
Related articles
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.
Someone rebuilt IDM from the outside and wrote down what they did not touch
A Rust reimplementation of Internet Download Manager claims 5x the speed and 86 languages. The more interesting document is the paragraph explaining how it was built without copying anything.