How I AIVibe coding a 3D multiplayer game in 15 minutes—with no game dev experience | Cody De Arkland
CHAPTERS
- 0:00 – 1:01
From blank framework to feature-by-feature building (vibe coding mindset)
Cody previews his core philosophy: start with a broad idea, then iteratively build and refine individual features. He notes this approach applies to games and “real” software alike, especially when starting from an empty scaffold.
- •Vibe coding as iterative feature development rather than a single perfect plan
- •Starting from a blank framework and progressively adding capability
- •Games as a useful stand-in for general app-building workflows
- 1:01 – 2:32
Meet Cody + what “27 words into a prompt” can produce
Claire introduces Cody De Arkland and frames the episode’s goal: live speed-running a 3D multiplayer game with AI tools. The premise is that minimal prompting can now yield surprisingly complete interactive prototypes.
- •Cody’s background (Developer Experience at Sentry) and prolific AI prototyping
- •Episode promise: build a 3D multiplayer game live
- •Contrast between tiny prompt input and large output results
- 2:32 – 4:32
Cody’s AI tool stack tour: Cursor, Windsurf, Claude Code, Bolt, MCP
Cody shares how he keeps multiple AI tools open simultaneously, treating them like “junior developers” assigned to different tasks. The tour highlights his pragmatic, multi-tool workflow across work and personal projects.
- •Using multiple AI IDEs/editors at once (Cursor and Windsurf)
- •Claude/Claude Code for terminal-driven coding and rapid iteration
- •Bolt for quick experiments and “meme apps”
- •MCP/Claude integrations as part of the workflow
- 4:32 – 7:00
Reverse-engineering Spaceflight: the multiplayer 3D space game he built
Cody demos Spaceflight (spaceflight.gg), explaining how it evolved from a simple prototype into a multiplayer experience. He emphasizes he had no prior game-dev experience—just iteration, tool-assisted learning, and constant refinement.
- •Spaceflight as a live, playable multiplayer browser game
- •Started as a basic scene and a placeholder cube spaceship
- •Iterative growth: visuals, controls, ships, and multiplayer added over time
- •Accessibility: anyone (including kids) can experiment and build now
- 7:00 – 9:49
How Spaceflight came together: Three.js, 3D models, and learning by asking ‘how’
Cody describes the back-and-forth process of getting 3D movement, controls, and imported ship models working correctly. He explains how he uses AI not just to generate code, but to learn underlying concepts (glTF/GLB, orientation, positioning) so he can repeat patterns across assets.
- •Three.js scene setup as the foundation
- •Importing Sketchfab models and dealing with orientation/forward direction
- •Learning terms and formats (glTF/GLB) through AI-guided explanations
- •Once solved once, reapplying the same logic to add more ships quickly
- 9:49 – 12:12
Live build begins: bootstrapping a new flight simulator from an empty Vite/React app
Cody starts a brand-new project (“boop flight”), initializes Claude Code, and prompts for a polygon-style Three.js flight sim. He explains why he keeps prompts broad at first: ship a v0, then tighten requirements through iteration.
- •Starting with npm create + an empty React/Vite scaffold
- •Claude Code init to build project context (claude.md)
- •Prompting for: Three.js, polygon art, WASD movement, banking turns, arrow-key pitch
- •Strategy: broad strokes first, then refine feature-by-feature
- 12:12 – 13:49
Prompting strategy: avoid ‘mountain plans,’ ship v0, then add complexity gradually
Cody outlines why overly detailed, end-to-end project plans often fail with LLM coding. His approach is to request a baseline prototype, then layer in complexity in small increments—similar to how he builds productivity apps and work software.
- •Why hyper-detailed prompts can backfire and frustrate builders
- •Chunking work into discrete improvements (v0 → iterative upgrades)
- •Applying the same method to home productivity tools (tasks, auth, database, etc.)
- 13:49 – 17:10
How he chooses libraries & architectures: ask AI, validate with docs, feed learnings back
Claire asks how Cody knows which technologies to pick, and Cody explains his loop: ask the model for options, do traditional research, then return with findings and implementation requests. He also uses the AI as a reviewer to catch race conditions and architectural issues (e.g., WebSockets).
- •Using AI to survey tech choices (browser game stacks, multiplayer approaches)
- •Following up with Google/docs deep-dives for grounding
- •Feeding external learnings back into the model for implementation
- •Using AI for code review: race conditions, disconnect handling, optimization
- 17:10 – 19:14
First run: a playable game appears—then the real debugging starts (camera & controls)
They run the project and immediately have a working 3D flight experience—along with classic early-stage issues like reversed camera direction and inverted controls. Cody demonstrates rapid feedback prompting to fix camera placement, plane orientation, and input mapping.
- •V0 success: instant playable prototype from minimal prompt
- •Diagnosing issues: camera facing the nose vs. tail, reversed forward direction
- •Iterating via precise language (“nose,” “tail,” camera slightly above/behind)
- •Claude Code visibility into what’s changing during edits
- 19:14 – 20:45
Parallelizing with multiple AI agents: ‘dueling Claude’ for frontend + server
Cody opens a second Claude Code instance and starts a server directory in parallel to add multiplayer features while the main game continues to be refined. He explains how this mirrors delegating work to multiple junior devs simultaneously.
- •Creating a server folder and initializing a backend alongside the frontend
- •Prompting multiplayer: joins, chat UI, movement updates, disconnects
- •Using parallel AI sessions to increase throughput and experimentation speed
- 20:45 – 24:01
Unexpected upgrades (and chaos): new scenery, UI elements, and unrequested features
As fixes land, the prototype gains extras Cody didn’t ask for—mountains, runway/flight strip, scrolling/zoom quirks, and camera view changes. The chapter highlights the tradeoff of fast AI iteration: delightful surprises mixed with regressions and “why did it do that?” moments.
- •Unprompted additions: mountains, runway/terrain changes, control overlays
- •Regressions: camera/controls still partially wrong after fixes
- •New behaviors appear (scroll wheel, cockpit-like view) without being requested
- •Managing the ‘two steps forward, one step back’ nature of AI coding
- 24:01 – 25:36
Multiplayer test: multiple players visible, chat partly broken, but real progress in minutes
They validate multiplayer by opening additional tabs and seeing multiple players in-game. Even with layout issues and rough edges, Cody emphasizes the time savings: something that could take hours/days is now a working prototype in roughly 15 minutes.
- •Backend changes complete; seeing joins and multiple players in-session
- •Chat/UI layout issues and screen region mix-ups
- •Proof of concept: multiplayer presence + basic networking behavior
- •Time comparison: manual build vs. rapid AI-assisted prototype
- 25:36 – 26:49
Making iteration productive: planning lightly, resetting when off-track, tightening scope
Claire and Cody reflect on the iterative process and how to recover when the AI gets ‘squirrely’—breaking things or adding irrelevant features. Cody shares tactics: restart a subproblem, restate requirements, simplify, and focus prompts narrowly to keep context clean.
- •Light planning and clear rules help—but iteration is the core accelerator
- •Reset tactics: ‘start over,’ ‘fresh look,’ restate main requirements
- •Scope reduction: fix one UI issue (e.g., chat position) while ignoring the rest
- •Using rules/memories (Cursor rules, Windsurf memories) to guide behavior
- 26:49 – 31:43
Lightning round: applying vibe-coding workflows to real work + closing message
Cody explains the overlap between playful projects and professional software work: same workflow, different ‘skin,’ guided by intentionality. He closes by inviting people to build, share, and stay excited about how accessible creation has become.
- •Game-building and enterprise/dev SaaS share similar build/iterate workflows
- •Intentionality: choosing when to build ‘fun’ vs. ‘work’ projects
- •Where to find Cody (X @codydarkland)
- •Call to action: share what you build; building is more accessible than ever
