This is the stretch goal of the series, and it's being named as one honestly. Everything from Layer 00 through Layer 10 builds toward shipping web apps and SaaS products — a world where "AI, build me a working thing" increasingly holds up. Games are a different animal: they run in real time, they live or die on how they feel in your hands (not just whether the logic is correct), and the tooling for AI-assisted game development is younger and shakier than the tooling for web apps. If you've read this far, you've earned the right to know where that frontier actually is in September 2026 — not where the hype says it is.
The good news: small 2D games and prototypes are genuinely within reach for a non-coder PM using AI tools today. The honest news: "I'll vibe-code a 3D game like the ones I play" is not a scoped first project — it's a multi-year studio effort, AI or not.
00 — Why games are a different kind of build
A web app's success criterion is mostly binary: does the button work, does the data save, does the page load. A game's success criterion is a feeling: does jumping feel good, is the enemy's timing fair-but-hard, does the difficulty ramp keep you in flow. Game developers call this "game feel" — the tactile, moment-to-moment responsiveness of controls and physics that separates a game that's technically functional from one that's fun. Game feel is tuned through hundreds of tiny numeric adjustments (how many milliseconds before a jump registers, how much the camera shakes on impact) and playtesting — not something an AI model can infer from a prompt, because it's subjective and only surfaces when a human actually plays the thing.
Games also run under much tighter real-time performance constraints than a typical SaaS page — a game needs to redraw the screen 30-60+ times per second no matter what's happening, which is a fundamentally different engineering problem than a web request-response cycle.
01 — Landscape: the three engines you'll actually hear about
For a beginner, three engines cover nearly everything worth considering. "Engine" here means the software that handles rendering graphics, physics, input, and packaging your game for a platform — the equivalent of a web framework, but for real-time interactive graphics.
| Engine | Current licensing/pricing (as of late 2025/2026) | Best for | AI-tooling maturity |
|---|---|---|---|
| Unity | Free "Personal" plan for studios/individuals under $200K/year in revenue and funding; Pro is roughly $2,310/year per seat (a further ~5% price rise took effect January 2026); Enterprise is custom, required above $25M revenue. Unity's controversial per-install "Runtime Fee" was announced in 2023, publicly backlashed against, and fully canceled in September 2024 — it does not apply to any Unity game. | 2D/3D games, mobile, most commercial indie and mid-size studio projects; the largest talent pool and asset marketplace | Highest — official "Unity Muse" AI chat/asset tooling built into the editor, plus a large ecosystem of third-party copilots, but most still assume you can read C# |
| Godot | Completely free and open source (MIT license) — no revenue thresholds, no royalties, no runtime fee, ever. You fully own anything you make with it. | 2D games especially, indie 3D, anyone who wants zero licensing risk or surprise fee changes | Fast-growing — several "agentic" AI copilots now target Godot specifically (e.g., Summer Engine), which can write GDScript (Godot's Python-like scripting language), run the game, read the error, and self-correct; still less mature than Unity's ecosystem |
| Phaser | Free and open source, no license fees. Runs on JavaScript/TypeScript — the same language stack as most modern web apps. Phaser 4 (current major version in 2026) added a much faster renderer. | Browser-based 2D games, casual/web games, projects you want to ship as a web page like the rest of your AI-built products | Moderate — because it's plain JavaScript, general-purpose AI coding tools (the same ones you used in Layer 03) can write and debug Phaser code directly; no dedicated in-engine agent ecosystem yet, but the code assistant you already know how to use just works |
Two other names you'll hear but that don't belong in a first project: Unreal Engine (Epic's engine — free until a game earns real revenue, then a royalty applies — but built for high-end 3D and console/PC titles, a steep climb for a beginner) and the wave of "prompt a whole game" web tools (Rosebud, various "AI game generator" startups) that are fine for quick throwaway prototypes but produce shallow, hard-to-extend games once you want anything custom.
02 — Where "prompt it into existence" genuinely works
The honest yes-list, based on what's actually shipping in 2026:
- Simple 2D games: platformers, puzzle games, top-down arcade games, card/board game digital versions. These have well-understood mechanics that AI models have seen thousands of times in training and tutorials.
- Jam-style projects: a scoped, single-mechanic game built over a weekend (the "game jam" tradition) is the sweet spot — small enough that an AI copilot can hold the whole codebase in context and iterate with you in real time.
- Prototypes to test a concept: if you're a PM validating "is this mechanic fun at all" before committing a team, an AI-assisted Godot or Phaser prototype gets you a playable version fast.
- Non-gameplay layers: UI screens, menus, save/load systems, simple enemy AI patterns, and level-editor tooling — these look a lot like the CRUD (create-read-update-delete) work AI coding tools already handle well in SaaS contexts.
The in-engine "agentic" copilots (tools that can write code, run the game, read the runtime error, and fix it themselves — the same read-execute-fix loop you learned about agentic coding tools in Layer 03) are the newest and most promising piece: they close the gap between "AI writes code" and "AI verifies the code actually runs," which matters enormously in games because a broken build gives you nothing playable at all.
03 — Where it still falls short
- Complex 3D: AI-generated 3D models and environments typically need substantial manual cleanup — correct scale, collision shapes (the invisible boundaries that make objects solid), materials that match your renderer, and rigging (skeleton setup) if anything needs to move or animate. Generating the asset is the easy 20%; making it work correctly inside your game is the hard 80%, and that part still needs a human who understands the engine.
- Performance-critical systems: physics engines, networking/multiplayer sync, and anything that needs to run at a locked frame rate on constrained hardware (mobile, consoles) is exactly the kind of work where a subtle AI-introduced inefficiency compounds into a stuttering, unplayable game — and where you, as a non-coder, have no way to diagnose it yourself.
- "Real" game feel and polish: the tuning pass — juice, feedback, difficulty curves, the hundred small numbers that make a game satisfying — is fundamentally a playtesting-and-iteration loop between a human and the game, not a prompting task. AI can help you implement a tweak fast; it can't tell you which tweak the game needs.
- Whole-game generation from a single prompt: the "type a sentence, get a finished game" tools are real for producing something playable in minutes, but they consistently produce shallow, hard-to-customize results the moment you want a specific mechanic that wasn't in their training patterns.
04 — How to actually do this: a realistic first project
Coming from a web/SaaS background, resist the urge to build the game in your head — the RPG, the multiplayer shooter, the open world. Scope down hard for project one.
The project: a single-screen 2D game with one core mechanic, playable in under 2 minutes, with no save system, no multiplayer, and no more than 3 levels. Classic beginner-appropriate shapes: a "catch the falling objects" game, a simple platformer with one type of enemy, a matching/puzzle game, or an endless-runner.
The stack: pick based on which risk you'd rather take on. - Godot + an in-engine AI copilot if you want to learn a real, free, professional-grade engine and are comfortable with a new tool outside your browser. - Phaser + your existing AI coding tool (the same agentic coding tool from Layer 03) if you'd rather stay inside the JavaScript/web workflow you already know, and want the game to be a webpage you can deploy like any other project from Layer 06.
The process: 1. Write a one-paragraph spec before touching a tool — borrow the spec-to-prompt discipline from Layer 01. Name the one mechanic, the win condition, the lose condition. Resist adding a second mechanic. 2. Have the AI copilot scaffold the project structure and get something on screen — a square that moves — before anything else. This is your equivalent of a SaaS "hello world"; if this step is broken, nothing downstream will work either. 3. Build and test in the tightest loop you can manage: one small change, run it, actually play it yourself, adjust. This loop is non-negotiable in games in a way it isn't always in SaaS — you cannot evaluate "is this fun" by reading the code or the AI's description of what it did. 4. Get 2-3 other humans to play it before you consider it done. Watch them, don't narrate. This is your QA layer (formalized further in Layer 09), and in games it's irreplaceable — no AI checklist tells you a jump feels bad. 5. Ship it somewhere trivial to share: for Phaser, a static web host works exactly like the deployment steps in Layer 06; for Godot, export to an HTML5 build and host it the same way, or use a platform like itch.io built for exactly this.
05 — Common mistakes beginners make
- Starting with 3D. It roughly triples every category of difficulty — asset creation, physics, camera control, performance — for a first project that doesn't need any of it to prove the concept.
- Underestimating "game feel." Assuming that once the logic works, the game is "done," the way a working API endpoint is done. It isn't — the tuning pass is most of what separates "technically a game" from "a game people enjoy," and it can't be delegated to a prompt.
- Scope creep from feature-brain. A PM's instinct is to spec a full feature set upfront (inventory system! leaderboards! multiplayer!). In games, every one of those is a separate hard problem, and stacking them before the core mechanic is fun guarantees you finish nothing.
- Skipping human playtesting because the AI tool said the build "works." Working and fun are unrelated claims — a game can run perfectly and still not be worth playing for thirty seconds.
- Picking Unity for a throwaway prototype out of brand-name familiarity, then getting tangled in editor complexity that Godot or Phaser would have avoided for a project this small.
Where this leads
Shipping a game — even a tiny one — completes the builder's tour: you've now taken an idea through web apps, SaaS backends, mobile, and real-time interactive software, using AI tools honestly matched to what each medium actually demands. Before you close the series out, it's worth stepping back and naming the vocabulary you've been using without a label for it — the stocks and flows, the coupling, the essential-versus-accidental complexity that's been quietly underneath every layer so far. That's Layer 12, a systems-thinking primer, and it's the bridge into Layer 13, Product Ops for the AI Builder, which closes the series by turning everything you've built here into a repeatable practice.