AI game development — landscape report

Where the AI-vibe-coder crowd is shipping, where they’re stuck, what the tooling battle actually looks like in May 2026, and a set of opinionated bets for evolving a casual single-shot mobile game studio into something that survives contact with real 3D and non-mobile work.

1. The AI-gamedev tooling landscape

The May 2026 picture is that there isn’t a single “AI game dev” tool — there’s a stack of general-purpose AI coding assistants that some people aim at games, plus a thin layer of game-specific products. The general-purpose tier is consolidating fast. By April 2026 the conversation centers on Cursor, Claude Code, GitHub Copilot, Replit Agent, and OpenAI’s Codex CLI/Agent (DigitalApplied’s 2026 comparison). Cursor reportedly hit $2B ARR in 24 months with 360,000+ paying customers; Replit went from $10M to $100M ARR in nine months after Agent mode shipped (Stormy AI breakdown).

Cursor

Cursor is the editor (a VS Code fork) that dominated “vibe coding” in 2025. It’s the primary tool levelsio used to build fly.pieter.com (a 3D multiplayer flight sim) in three hours — the demo that catalyzed the entire phenomenon (onepromptman.ai retrospective). For gamedev, its strengths are tab completions, fast iteration, and the open-ended ability to call any model. Pricing: Hobby (free), Pro ($20), Pro+ ($60), Ultra ($200), Teams ($40/user). Its credit-based billing surprises heavy users — Builder.io documented “$10-20 daily overages” reports (Builder.io comparison). The Cursor Composer is what most jam entrants name as their main interface.

Claude Code & the Claude Agent SDK

Claude Code is Anthropic’s CLI-first agent. It runs locally, has full 200K-token context with Sonnet/Opus, and stitches into MCP servers (Slack, GitHub, Playwright, custom). Builder.io’s opinion: “Claude Code excels when you need to move a lot of code across a repo” — multi-file refactors, autonomous longer-horizon work. The Claude Agent SDK is the same harness exposed for building your own agent products; Anthropic positions it as “the general-purpose harness behind Claude Code” that already powers research, finance, and support agents in the wild (Northflank).

For gamedev specifically, the most interesting trend is the rise of Claude-Code skills targeted at Three.js, R3F, ECS, and WebGPU — e.g. emalorenzo/three-agent-skills, Nice-Wolf-Studio/claude-skills-threejs-ecs-ts, dgreenheck/webgpu-claude-skill. The pattern is “don’t fine-tune the model, fine-tune the context” — bundled docs, API signatures, and best-practice rules loaded into .claude/skills/.

OpenAI Codex CLI / Agent / Operator

Codex CLI is open-source (Apache 2.0, 67k+ stars). The Codex Agent is the cloud counterpart — runs in isolated sandboxes, designed for delegated PR-from-anywhere work. Ivan Trakhtenberg’s framing: Codex is the “agentic planner”, Claude Code is the “shell-first surgeon” — Codex is cheaper per task and better sandboxed by default, Claude Code is the better pair-programmer (Medium). For gamedev the Codex tooling is fine for code-only loops but lags on the rich ecosystem of game-tuned skills/MCP servers.

Replit / Replit Agent

Replit’s pitch is “AI as hosted dev environment.” Agent 4 (March 2026) writes code, manages auth and DBs, and ships in real time on .replit.app. Three.js projects are supported as a project type. But Replit Agent’s reputation in the gamedev community is mid: Superblocks’ honest test notes you’d “rewrite approximately 40% of what the Agent generated” to ship at scale, and the vendor lock-in (hosting + database) is real. It’s an excellent prototyping bench; very few of the 1,170 entries in 2025 Vibe Jam or the 945 entries in 2026 named Replit as their primary toolchain.

v0 by Vercel

v0 is “vibe coding for production apps,” nominally for UI. Vercel has been actively pushing it into 3D — their React Three Fiber integration means people do game-jam in v0, though the output is usually closer to interactive scenes than full games. v0 wins on hand-off: branch per chat, PR to main, Vercel deploy, full Git workflow that non-engineers can drive. Less common as a jam tool.

Lovable.dev

Lovable is React/TypeScript/Tailwind only and squarely aimed at SaaS, but it’s been used in 3D via Three.js prompts — their own case study documents a hackathon win on a 3D Three.js project. Lovable’s edge over Bolt is real two-way GitHub sync; weakness is the “last 10% of polish is where the real time goes” problem that hits every no-code builder.

bolt.new / StackBlitz

Bolt is the “zero-friction entry point” — browser, no setup, Node/Express backend. It’s the co-sponsor of Vibe Jam alongside Cursor. The official 2026 jam analysis recommends “Cursor Composer 3 and Bolt.new as fast, affordable options that work well with Three.js and games” (Summer Engine analysis). Its weakness is the same as Lovable’s: works great for the 80%, the last mile is brutal.

Rosebud AI

Rosebud is the only major game-specific vibe-coding platform with traction. Pitched as no-code 3D and 2D vibe-coding in the browser, target audience is “indie developers, designers, and artists who want to prototype or ship 3D games without a traditional code-heavy pipeline.” Critical limitation: browser-only output. Summer Engine’s 2026 Rosebud-alternatives roundup is blunt: if you want Steam or desktop, look elsewhere (Summer Engine, GDevelop, Godot, GameMaker).

Devin

Devin remains the most-overpromised, least-delivered tool in this space. IT Pro reported 3-out-of-20 completed tasks in independent testing. It has not shown up materially in gamedev case studies in 2026 search results.

GitHub Copilot Workspace & Spark

Workspace is now generally available on paid Copilot plans — issue-to-PR via a planning UI. Spark (Pro+/Enterprise) is the “Dream it, see it, ship it” app builder. Neither is game-tuned; both are general-purpose and OK for backend logic, weak on the visual iteration loop that games require.

Cline, Aider, Continue.dev

The OSS / private-cloud crowd. Cline has the strongest gamedev mindshare of these three thanks to its Plan/Act split and MCP support. Aider is terminal-first with strong git ergonomics. Continue.dev prioritizes governance and approval workflows. None has produced standout gamedev shipping stories, but all three appear in Three.js skill-pack readmes.

Game-specific tools: Inworld, Scenario, Layer.ai, Promethean.ai, Meshy, Tripo3D, Luma

The asset and runtime-NPC side has matured fast.

• Inworld AI — pivoted from NPC dialogue to a broader voice/agent runtime. Clients include Google, NVIDIA, Meta, Ubisoft, Xbox. AI NPCs are testing inside PUBG Arcade in 2026.
• Scenario.gg — train custom image models on your art style; node-based pipeline editor; the strongest 2D/sprite story.
• Layer.ai — 300+ models across image/video/3D/audio, enterprise pipeline focus.
• Promethean AI — level design / world building specifically; reported 70% reduction in level-design time in production usage.
• Meshy — the most end-to-end single-platform 3D pipeline (gen, retopo, auto-rig, 500+ animation presets).
• Tripo3D — text/image-to-3D, Silver sponsor of Vibe Jam 2026. Family covers generation, retopology, rigging, stylization.
• Luma Genie — visually impressive but output usually needs retopo before game-engine use.

The shape of the market. The general-purpose AI coding tools are eating the gamedev tooling lunch — not by being better at gamedev, but by being better at code. Cursor, Claude Code, and Bolt sponsored Vibe Jam 2026; the dedicated game tools (Rosebud, Summer Engine) showed up adjacent to it, not as the primary tooling. That tells you something about where the energy is.

2. Vibejam 2026 specifically

Vibe Jam is Pieter Levels’ brainchild, run twice now. The 2025 edition was sponsored by Bolt.new + CodeRabbit + Lambda; 2026 (which closed May 1, 13:37 UTC) is sponsored by Cursor (Diamond), Bolt.new (Gold), Glif and Tripo3D (Silver). Lead judge is @s13k_; jury includes Tim Soret (Odd Tales), Nicola Manzini (Vibesail), Eric Zakariasson (Cursor), Alessandro Schiassi (Over Jump Rally).

2025 results (the precedent)

1,170 games submitted. Levelsio and @s13k_ hand-pre-vetted to ~500 because many entries “didn’t even load.” Judges: Andrej Karpathy, Ricardo Cabello (mrdoob, Three.js author), Tim Soret, S13k. Winners (announced April 23, 2025):

1. The Great Taxi Assignment by Tomas Bencko — $10,000 — GTA-like taxi sim.
2. Vibeware by Matt Gordon — $5,000 — a game where you play a bot doing tasks.
3. Vector Tango by Scoble — $2,500 — air traffic control sim.

2026 final numbers

Per levelsio’s closing tweet:

And…..✔ DONE! The Vibe Jam of 2026 sponsored by @cursor_ai + @boltdotnew + @heyglif + @tripoai is officially closed. 945 games submitted. 242,212 players. ~12 million views on X. Now me and @s13k_ will start the judging process, probably pre-vetting games first… — Pieter Levels (@levelsio), May 1 2026

Judging is underway as of this report (May 12, 2026). Winners are not yet announced. Two entries are already viral:

• WenWare — a time-travel Geoguessr-inspired game with immersive 360° historical scenes, built in Three.js. Levelsio flagged this as “the first game in 2026 #vibejam that goes absolutely viral and I see shared in almost every chat group I’m in” — he had to double his php_max_workers because the Vibe Jam widget.js was getting hammered (tweet).
• Tiny Skies by @DannyLimanseta — a cosy parcel-delivery flying game on a tiny globe. Repo at github.com/dannylimanseta/tinyskies, built on Vite + TypeScript + Three.js + Socket.io with quaternion-based spherical math and slerp-interpolated client prediction. (Branch name is cursor/globefly-multiplayer-globe-flight-game — the heritage is plain.)

The portal mechanic — an emergent webring

The defining new feature of 2026 is the Vibeverse portal system. Optional entry/exit portals let players hop between jam games carrying state (?portal=true&ref=… query params with username, color, speed, HP). Levelsio demoed this himself: “I start in my plane game, then I go to @ky__zo’s goose game, then @martyamark’s metaverse and finally @NicolaManzini’s Vibesail world” (tweet). The 2026 jam page provides copy-paste Three.js snippets for portals. This is the first time a jam has produced a shared world as a side-effect of independent submissions — arguably the most interesting cultural artifact to come out of vibe coding.

Rules & constraints

Per vibej.am/2026:

• ≥90% of code must be AI-generated (up from 80% in 2025).
• Web-accessible, free-to-play, no login, no heavy loading.
• One entry per person; games must be new (post-April 1).
• Mandatory widget.js tracking snippet.
• Multiplayer preferred; any engine permitted; Three.js recommended.

Patterns that emerged

From cross-referencing the chongdashu/vibejam-starter-pack, majidmanzarpour/vibe-coding-starter-pack-3d-multiplayer, VibeGame, and the 2025 retro:

• Three.js wins, full stop. Nothing else has the same volume of training data, llms.txt support, or community skill packs.
• Single-mechanic, single-screen games dominate. Sim/sandbox/runner archetypes outperform anything narrative.
• Multiplayer is the differentiator — SpacetimeDB, Socket.io, and PartyKit are the three names that surface repeatedly.
• Aesthetic is “low-poly cosy” — sphere worlds, pastel skies, simple geometry. Tiny Skies, Vibesail, and Threevial all live in this style. It hides the AI’s asset weaknesses.
• The viral games have one mood and one verb (fly, sail, deliver, explore-history). Anything with combat, inventory, or progression mechanics struggles — see the VibeGame post for why.

Jonathan Blow publicly questioned the depth of the 2025 entries. Levels pushed back: “speed, iteration, and fun” over “gatekeeping.” The 2026 quality bar is visibly higher — Tiny Skies in particular is a real game.

3. AI-game-dev workflows in JavaScript

The framework hierarchy (as of May 2026)

Utsubo’s 2026 comparison gives the cleanest numbers:

Three.js has ~270x the weekly downloads of its closest competitor in the “creative coding” substrate measurement (metavert.io). LLMs learned 3D web via Three.js; everything else is a distant second. For 2D games, Phaser’s own February 2026 tutorial is on building a 2D shooter with Claude Code — the framework is leaning into AI-fluency hard. Phaser Editor v5 added explicit AI integration in 2026.

Project structures that let AI iterate

The pattern that has emerged across successful jam entries and skill packs:

• Single-file or tightly-grouped for prototypes — one index.html + one big script keeps the AI’s mental model coherent.
• ECS once it grows — bitecs is the recommended ECS framework for Three.js + AI workflows (used by VibeGame). The data/behavior split is exactly what LLMs handle well.
• Tweak schemas — a JSON file declaring what numbers to expose (speed, gravity, density). awfml’s own orchestrator template (tweaks.schema.json) is doing the right thing here. Pattern:

{
  "playerSpeed": { "type": "number", "default": 5, "min": 1, "max": 20 },
  "gravity":     { "type": "number", "default": 9.8, "min": 0, "max": 30 },
  "skyColor":    { "type": "color",  "default": "#87ceeb" }
}

• Asset manifests — declarative list of sprites/audio/models the game needs. The orchestrator can fan-out generation jobs.
• llms.txt or CLAUDE.md at the project root with API patterns and architecture context. majidmanzarpour’s starter ships one for SpacetimeDB v2 patterns; this is increasingly standard.

Common stuck points

• Physics. Jack Le Hamster’s post-jam: “Cursor struggled with basic collision detection, suggesting distance calculations instead of using built-in physics engine events… ‘Ammo.js’ was hallucinated.” (dev.to). Cannon.js, Rapier, and Ammo.js are real; LLMs confuse them.
• Multiplayer state. Universally cited as the canyon. Ziva’s breakdown: “the most challenging aspects of vibe-coded multiplayer games were the multiplayer synchronization and hit detection.”
• Asset pipeline. Generated sprites work fine for backgrounds and tiles; characters with consistent identity across poses fail. Rigged 3D animation is brutal.
• Performance. Vibe-coded games regularly ship with rendering loops that don’t pool, materials that don’t share, and shadow maps that crater mobile FPS.
• Save-state persistence. Localstorage works; cloud saves don’t arrive without serious scaffolding.
• Mobile UX vs desktop. Cursor & co. default to WASD; mobile touch controls and portrait layout require explicit prompting and rarely come right first try.

Asset sources

The actually-used pipeline in 2026:

• Hand-curated free — Kenney (60k+ free assets), OpenGameArt, Sketchfab.
• Generated 2D — Scenario (best for sprite consistency), Stable Diffusion variants, Retro Diffusion (pixel art — see vibejam-starter-pack for skills wiring), gpt-image-2 (awfml’s current default — drifts on grid-aligned tilesets per his own notes).
• Generated 3D — Meshy, Tripo3D, Luma Genie. Tripo is Vibe Jam’s 2026 Silver sponsor for a reason.
• Audio — ElevenLabs for SFX and voice (cheapest game-soundtrack story in production), Suno/Udio for music (Udio has cleaner licensing post-UMG settlement Oct 2025), Stable Audio for sound design beds, AIVA for cinematic scores.

Controls & input

The vibe-coded standard: keyboard + mouse for desktop, pointer-events polyfill for touch. Three.js’ pointer-lock and standard event model is well-covered in training data. Gamepad and gyro work but rarely get prompted. Webcam/AR via WebXR is essentially absent from jam entries despite Three.js supporting it.

4. The Unity / Unreal / Godot question

Why don’t the AI-vibe-coders use the “real” engines? Ziva’s scoreboard tells the story:

The friction with Unity

• Editor-required workflow. A Unity project is more than C# — it’s .meta files with GUIDs, YAML scene/prefab serialization that’s machine-fragile, asset import pipelines, and an inspector that is the gameplay surface. AI tools can write the code; they can’t reliably write the scene.
• Binary assets. AI can’t generate .unity scene files coherently because the GUID references are stateful and non-local.
• Build chains. Building for iOS/Android requires Xcode/Gradle and a 30-min CI pipeline; the “hot reload, see it in browser” loop is gone.

What does work: Cursor on the C# files inside a Unity project, plus an MCP bridge into the editor. CoplayDev/unity-mcp and IvanMurzak/Unity-MCP are the two leading Unity MCP servers. Unity AI is Unity’s own first-party integration shipping inside Unity 6.

The friction with Unreal

Blueprints are visual scripting — literally a binary asset graph. AI can’t edit them. C++ in Unreal is heavy, slow to iterate, and the build pipeline is hostile to fast feedback. AI fluency is the lowest of the four (~40 in Ziva’s scoring). Unreal does have an MCP integration story but it’s much earlier than Unity’s.

Godot’s structural edge

Godot is the AI-friendly “real engine.” GDScript is plain text, Python-like, and the entire engine surface fits in a 120MB binary. Crucially, .tscn scene files are text — LLMs can read and edit them directly. Summer Engine’s 2026 Godot tooling list includes Summer Engine itself (AI baked into the engine), Ziva (editor plugin, $20/mo Pro), GDAI MCP (open-source MCP server), and AI Assistant Hub (community plugin). The fact that Vibe Jam 2026 explicitly accepts Godot Web exports is meaningful — you can ship Godot to Steam and the jam.

Can a game be fully built in code without a viewport editor?

The honest answer: yes for small-to-mid 3D, no for AAA, “depends” in the middle.

What an editor gives you that pure code can’t (yet) replicate:

• Spatial intuition. Dragging a light to taste in a scene is faster than the prompt-eval cycle. Metavert’s “modality gap” thesis: “We’re forcing visual communication through a text bottleneck. It’s like directing a painter by writing letters instead of pointing at the canvas.”
• Inspector + live tweaking. Adjusting a value while the game runs, watching the effect. This is what awfml’s Tweaks panel already does in miniature.
• Asset import pipeline. Texture compression, mip generation, LOD bake — expensive offline tooling.
• Hot reload of scene state without reloading code.
• Scene-graph manipulation at a level a structured text format can’t cleanly express.

What you can replicate in code: gameplay logic (obviously), spawn rules, level data as JSON, even crude scene graphs. The editor becomes load-bearing when (a) the asset count gets large enough that batch import dominates iteration, (b) lighting/material polish becomes the differentiator, (c) animators and designers need a non-code surface. For a single-developer 5-hour-of-content browser game, the editor is overhead, not value. For a 40-hour 3D RPG, the editor is the only way to get there.

5. The bridge to advanced 3D and non-mobile

Three.js, R3F, Babylon, PlayCanvas, A-Frame

• Three.js — the king for AI iteration. WebGPU support is now production-ready across all major browsers as of Sept 2025; Three Shader Language (TSL) lets you write shaders once and target WGSL+GLSL. Compute shaders enable up to 150x particle-system speedups (Three.js Roadmap). The bridge to advanced 3D is here.
• React Three Fiber (R3F) — the declarative-React layer. Specialized skill packs exist (emalorenzo/three-agent-skills) because base LLM training data on R3F is “outdated or incomplete.” The R3F path lets you reuse your React tooling, your existing UI components, your devtools.
• Babylon.js — better “batteries included” for game-specific needs (physics, audio, XR), but the 1.4MB bundle and lower AI-fluency keep it second.
• PlayCanvas — has a visual cloud editor (“Figma for 3D”), VS Code extension, Gaussian-splat support. Most of the gameplay logic in PlayCanvas demos is now iterated from Cursor, per their team. Smaller community.
• A-Frame — declarative HTML-style 3D; not really shipping commercial games in 2026.

WebGPU, compute shaders, raytracing

This is where AI can genuinely move the needle. Compute shaders for fluid sim, physarum, reaction-diffusion, GPU particles — all in dgreenheck’s WebGPU Claude Skill. Three.js 2026 inflection: WebGPU is the dominant rendering path; AI-assisted dev is lowering the barrier; the library is leaving websites and entering physical installations. WebGPU + AI is a real frontier.

Multiplayer infrastructure

• Colyseus — Node.js authoritative multiplayer framework, SDKs for every engine, delta-compressed state sync. The most mature browser-game choice.
• PartyKit — Cloudflare Workers-backed, WebSocket+Y.js+tldraw friendly. Great for real-time collab.
• SpacetimeDB — the standout 2026 pick for vibe-coded multiplayer. Rust WASM server, client-side prediction + slerp interpolation built into the starter pack. Used in Tiny Skies, in majidmanzarpour’s starter.
• Socket.IO — the fallback for non-authoritative games.
• Geckos.io — WebRTC unreliable channels, low latency. Rarely surfaces in vibe content.

Distribution

• Web — the default; instant playable; the entire jam ecosystem.
• itch.io — web builds + lightweight desktop wrappers; the gold standard for indie release.
• Steam — the Mt. Everest. Realistic for Godot/Unity output, very hard for raw web games unless wrapped. CODEX MORTIS shipped to Steam in March 2026 as a “100% AI-driven” action RPG — small but real signal that pure-AI games are reaching Steam.
• Tauri — Rust-based webview wrapper, ~96% smaller than Electron, 0.4% battery/hr on M3 vs Electron’s 2.1% (tech-insider.org). The cleanest path to Steam from web.
• Electron — still the most-shipped wrapper; ugly but works.
• Capacitor — for mobile native (iOS via Xcode; Android via Gradle). awfml’s template already has this story implicitly via Vite/PWA.

Pro tier vs casual single-shot

6. Where people get stuck (and where they succeed)

The repeatable failure modes

• The 80/20 inversion. AI writes 80% in 10 minutes. Debugging the last 20% takes 10 hours. Cursor user reports of “bug loops that consumed credits” (Lovable comparison) and earezki’s 2026 audit finding: “AI co-authored code contained 1.7x more major issues than human-written code, and 45% of AI-generated code samples contain OWASP Top-10 vulnerabilities.”
• Context exhaustion as the game grows. Even Claude Code’s 200K window fills fast on a multi-file game. The Carnegie Mellon study of 807 repos found AI-assisted code had 41% higher complexity; velocity gains evaporate within 2 months, technical debt persists (Ziva).
• Asset-quality gap. Procedural textures: fine. Mid-quality sprites: usable. Characters with consistent identity: hard. Rigged 3D animation: brutal. This is the main reason “low-poly cosy” dominates — it sidesteps the gap.
• Multiplayer netcode. The single biggest canyon. Even starter packs that solve it (SpacetimeDB, Colyseus) require human understanding of authoritative state, lag compensation, prediction reconciliation. Pure vibe-coding falls off this cliff every time.
• Performance once the game gets real. Materials don’t get shared; objects don’t get pooled; shadow maps obliterate mobile FPS.
• Self-testing blind spot. Jack Le Hamster’s lament after his jam: “it was unable to figure out that the code was wrong… Why can’t it test its own code? It’s like having a famous composer who’s completely deaf.” Playwright-based canvas testing skills exist (in chongdashu’s starter pack) but they’re primitive.

What successful AI vibe-coded games share

• Small scope — single mechanic, single screen, single verb.
• Juicy moment-to-moment feedback — particles, sound, screen shake.
• Generated assets used selectively, not wholesale.
• Tight playtest loop — the developer can hit reload in 1 second.
• A real human in the architecture chair — “Senior developers, who got the most quality benefit (68.2%), were least likely to skip review” (Ziva).
• Cosy/cute aesthetic that hides asset weakness.

What ACTUALLY ships vs throwaway demos

Three data points:

1. fly.pieter.com — built in 3 hours, monetized in days, $87k MRR by day 17 (retro). Real revenue.
2. Nicolas Zullo’s WW2 dogfight arena — 45,000 players, zero human-written code (per Ziva).
3. Ágoston Torok’s CEO Simulator — 10,000 players in one weekend.

Pattern: single-verb, instantly understood, infinite replay loop, viral shareable moment.

7. Competitive landscape — where these tools collide

The cleanest framing: there are four distinct shapes of AI dev tool, and they only partly compete.

Where each one wins for gamedev

Cursor wins when you’re a competent dev doing rapid Three.js iteration. Tab completion in a known codebase is unbeatable. It’s the de facto Vibe Jam tool. Builder.io’s honest take: “Tab completions remain Cursor’s strongest exclusive feature.”

Claude Code wins when you’re doing serious multi-file work or building tooling around the game (asset pipelines, build scripts, generators). Its 200K-context reliability and MCP-first architecture make it the obvious choice for orchestrator-style products — which is exactly what awfml’s mobile-game-studio is. From Northflank’s 2026 review: “Claude Code is the better hand-on-the-keyboard pair-programmer in 2026 — higher quality on hard tasks, larger context, deeper IDE integration. OpenAI Codex is the better autonomous worker.”

Replit Agent wins when the user wants no setup at all and is OK with the lock-in. Its growth ($10M to $100M ARR in 9 months) proves there’s a real market — mostly people who don’t have a local dev environment.

Bolt and Lovable win on initial demo creation. Bolt is the fastest first-game-on-screen. Lovable wins for production-grade React/TS output with two-way GitHub sync. Neither is what serious gamedev jam winners reach for.

v0 wins when the “game” is actually closer to an interactive 3D web experience — portfolio pieces, marketing demos, R3F set pieces.

Rosebud wins when the user is a non-developer who explicitly wants gaming as their output and doesn’t care that it’s browser-only.

The Anthropic vs OpenAI tooling war

This matters because awfml’s project is built on Claude. The honest state of play:

• Cursor and Windsurf are model-agnostic — users pick Anthropic, OpenAI, or Google models inside them. Cursor leans Anthropic in defaults, but neither company “owns” it.
• Claude Code (CLI) and OpenAI Codex CLI / Agent are the direct first-party plays. They are explicitly competitive products.
• Devin uses both. Replit Agent runs primarily on Anthropic. GitHub Copilot runs primarily on OpenAI but has added Anthropic.
• Anthropic’s competitive advantage is the Agent SDK — the same harness behind Claude Code, exposed for downstream products. Building on it means you compose Claude’s reasoning, MCP’s tool surface, and your own orchestration logic. That’s the architectural moat for orchestrator-style products like awfml’s.
• OpenAI’s counter is Codex Agent + Agents SDK + the cookbook ecosystem — a more mix-and-match story.

For awfml’s positioning: Claude Code & the Agent SDK are not competitors — they’re the substrate. The real competitors to mobile-game-studio are Rosebud (same target user) and Bolt for casual games (overlapping target user). Cursor and Replit Agent serve a different user (the one who already knows what code is).

Who’s eating whose lunch

• Cursor is eating GitHub Copilot’s lunch in solo-dev land. Copilot still has ~42% market share via enterprise GitHub deals, but the energy is with Cursor.
• Claude Code is eating Cursor’s lunch for autonomous multi-file work. Cursor responds with Composer; Claude Code is winning on the “long-running agent” axis.
• Lovable is eating Bolt’s lunch in production-grade no-code (GitHub sync, polish).
• Replit Agent is eating beginner mindshare from everyone — it’s the “I don’t even have VS Code installed” pick.
• Rosebud is mostly its own market — non-devs who specifically want games. It’s not really competing with the general-purpose tools for the same user.
• awfml’s mobile-game-studio sits in a small but real seam: people who want gamedev specifically, want output they can own (not Rosebud’s browser hostage), and don’t want to deal with Cursor-level dev tooling.

8. What this means for awfml’s project

The headline question: should the mobile-game-studio at bmo.ryanboye.com/mobilegamestudio add advanced tooling on top — and if yes, what?

Verdict: yes, but selectively. The current studio is well-positioned for a clear evolution — not as a Rosebud clone, and not as a Cursor competitor. The seam is “casual creator surface with a pro-tier underbelly that lets serious devs ship past the demo stage.” That’s a real market gap. Rosebud can’t go there because their UI is locked to non-coders; Cursor can’t go there because they don’t have a project model. The studio’s orchestrator+template+tweaks-rail architecture is the right substrate.

The competitive analysis suggests three strategic guardrails before picking individual bets:

1. Do not try to be Cursor. Don’t build an editor surface for arbitrary code. You’ll lose to a $2B company shipping daily.
2. Do not try to be Rosebud. Their lock-in (browser-only output) is their business model; mimicking it gives up your structural advantage.
3. Lean into “your code, your repo, your domain.” The fact that orchestrator output is a real Vite/TS project the user owns is underrated. That’s the upgrade path Rosebud can’t offer.

Here are the bets — ranked by strength of opinion.

The recommended order

If you can only do three things this quarter, do them in this order:

1. Bet 1 (Persistent workspace) — foundational, unblocks everything else.
2. Bet 2 (3D / Three.js template) — highest-leverage market wedge.
3. Bet 3 (Model router) — near-free, cuts cost dramatically.

Then in order: Bet 4 (asset providers, because Bet 2 needs Tripo3D), Bet 7 (session view, because Bet 1 makes it valuable), Bet 8 (import flow), Bet 6 (Steam/Tauri), Bet 5 (multiplayer, hardest and most uncertain).

The thing I’d bet money on if forced

The mobile-game-studio’s biggest moat is that the output is a real, owned, ejectable codebase. Every advanced bet should reinforce that — persistent workspace, 3D template, multiplayer, Steam export, import flow. None of those moves toward “more no-code”; all of them move toward “more code, better managed, by AI.” That’s the seam where Rosebud can’t go and Cursor doesn’t care to go. Sit there and own it.

The most surprising findings worth flagging

• The Vibe Jam 2026 portal mechanic produced an emergent shared world across hundreds of independent games — an accidental webring. This is the most interesting cultural artifact in vibe coding and may matter more than any individual game.
• The CMU 807-repo study’s finding that AI-assisted code has 41% higher complexity and velocity gains evaporate within 2 months is the most damning empirical critique of vibe coding to date — and it’s mostly ignored in the AI-tools marketing.
• Three.js’s 270x download advantage over its nearest 3D-web competitor is so large that AI tooling can’t really meaningfully target anything else. The substrate war is over.

Compiled May 12, 2026. Sources cited inline. Errors are mine; opinions are deliberate.