By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.

Vibe coding a 3D multiplayer game in 15 minutes—with no game dev experience | Cody De Arkland

Cody De Arkland is the senior director of developer experience at Sentry, leading a team that empowers developers to build and ship software with greater safety and efficiency.

Cody De ArklandguestClaire Vohost

May 5, 202531mWatch on YouTube ↗

Summaries, chapters, transcripts, and FAQs on this page are made by uListen, not YouTube.

CHAPTERS

Jump to publisher timestamps

Chapter summaries

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
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
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
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
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
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
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.)
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
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
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
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
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
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
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

Publisher timestamps

Get more out of YouTube videos.

Read along on your phone, search it beside the video, or ask your favorite AI app what was said.