How I AIVibe coding a 3D multiplayer game in 15 minutes—with no game dev experience | Cody De Arkland
CHAPTERS
Vibe coding as a general software workflow (games to “real apps”)
Cody frames vibe coding as a repeatable way to build software: start from a blank scaffold, give a broad direction, then iterate feature-by-feature. Claire tees up how this approach applies beyond games to everyday application development.
- •Start with an empty framework and a broad goal
- •Iterate by implementing one feature at a time
- •Treat the process like collaborating with another developer
- •Same method works for web apps and games
Cody’s AI tool stack and “junior devs” metaphor
Cody tours his desktop and explains how he runs multiple AI tools concurrently, treating each as a specialized helper. The segment highlights the practical reality of modern AI-assisted development: lots of parallel contexts and tools.
- •Uses multiple coding environments simultaneously (e.g., Cursor, Windsurf)
- •Keeps Claude and terminal-based tools open for different tasks
- •Also uses app builders like Bolt for work and personal projects
- •Frames tools as “junior developers” working in parallel
Showcase: Spaceflight.gg—multiplayer space flight sim built via AI
Cody demos his game Spaceflight, including login/name selection, ship choice, and live multiplayer presence. The game evolved from a simple prototype into a more ambitious project as he kept iterating.
- •Playable public demo at spaceflight.gg
- •Ship selection and named player identity
- •Multiplayer added after the initial build
- •Project “grew out of control” through iterative improvements
From intimidation to first game: how Spaceflight began
Cody explains he had no prior game dev experience and started with a simple ask: a space flight simulator. He describes the early ugly prototype (starfield + gray cube) and how repeated small requests shaped the game.
- •No prior game development background
- •Initial output was a basic scene with a placeholder ship
- •Progress came through back-and-forth tweaks (controls, motion, visuals)
- •Discovered hidden complexity (3D movement, orientation, camera)
Learning 3D assets and Three.js through the build (glTF/GLB, orientation, models)
As AI introduced new concepts, Cody used it to teach him what it was doing—especially around 3D model formats and importing. He details practical issues like model orientation, defining “forward,” and reusing fixes across assets.
- •Three.js chosen as a well-documented foundation
- •Learned about glTF/GLB models and how they load
- •Used Sketchfab models, then solved rotation/positioning quirks
- •Once a fix works for one ship, it becomes reusable for others
Live build kickoff: scaffolding a new flight sim with Vite/React + Claude Code
Cody starts a brand-new project from scratch and initializes Claude Code to ingest project context (claude.md). He emphasizes staying intentionally vague early to get a working v0 prototype, then refining.
- •Creates a fresh Vite/React project via CLI
- •Runs Claude init to capture structure/context in claude.md
- •Prompts for a Three.js flight sim with WASD + pitch/bank controls
- •Advocates broad prompts first, then incremental feature edits
Cody’s prompting philosophy: broad strokes, then controlled complexity
Cody contrasts lightweight planning with over-specified “mountain of tasks” prompts that often fail. He illustrates an iterative pattern—prototype, add one capability, validate, then layer in complexity (also used in productivity apps).
- •Avoid overly detailed master plans in one prompt
- •Think in “chunks” and iterate toward the ideal
- •Add complexity gradually (auth, DB, etc. in other apps)
- •Optimize for forward momentum over perfection
How he chooses libraries/tech: ask AI, then verify with research and feedback loops
Claire probes how he knows which technologies to use. Cody explains his loop: ask an LLM for options, do traditional research, then bring findings back to the model as if pairing with another engineer.
- •Uses AI to shortlist tech stacks (e.g., browser games → Three.js)
- •Evaluates multiplayer approaches (WebSockets vs alternatives)
- •Deep-dives via Google/docs, then feeds learnings back to the LLM
- •Uses AI for code review and bug-spotting (race conditions, cleanup)
First run surprise: a working game from a short prompt—then immediate debugging
The newly generated flight sim runs quickly and looks impressive, including an unexpected controls guide. But issues appear: camera is reversed and controls are inverted, prompting an iterative debugging session.
- •Rapid v0: game runs after minimal prompting
- •Unexpected extra UX (control guide) appears
- •Camera faces the wrong direction; movement feels backwards
- •Refines prompt language (“nose/tail”) to correct orientation
Parallelizing with multiple AI instances: building frontend and multiplayer backend simultaneously
Cody demonstrates a “not so often used hack”: open another Claude instance and start a server directory while the first continues UI/game fixes. He scaffolds an Express/WebSocket setup and asks for join handling + chat UI.
- •Runs two Claude Code sessions in parallel
- •Creates server folder, initializes npm, installs Express/Socket tooling
- •Requests multiplayer: joins, movement updates, disconnect handling
- •Adds a top-right chat interface and join notifications
Iteration outcomes: controls improve, unexpected environment features appear
As fixes land, the camera and visuals improve, but new issues and new features emerge—some not requested (mountains, flight strip, zoom, cockpit-like views). The segment captures the “two steps forward, one step back” reality.
- •Visuals improve (camera position and tail/nose framing)
- •Controls still need tuning (bank/turn mismatches)
- •Model/scene changes introduce surprises (terrain, mountains)
- •New behaviors appear without asking (scroll zoom, camera modes)
Multiplayer test in minutes: multiple players show up, UI bugs remain
They confirm multiplayer signals (joins) and open extra tabs to see multiple players in-session. While the chat and UI layout are imperfect, the core multiplayer loop exists far faster than a traditional build.
- •Server indicates joins; multiple players appear
- •Opening another tab confirms concurrent players
- •Chat window/layout issues and HUD placement are broken
- •Still, a functional multiplayer prototype emerges quickly
Reflection + lightning round: making AI “listen,” balancing fun vs work, and sharing builds
Cody reflects on the speed gains despite imperfections and outlines tactics for steering models when they drift. He closes with how his hobby workflow mirrors professional dev work, plus where to find him and why sharing projects matters.
- •Velocity is the win: a few hours/days compressed into ~15 minutes
- •When AI derails: reset, restate requirements, simplify scope
- •Use rules/memories (Cursor rules/Windsurf memories) for guidance
- •Balance fun vs work via intentionality; encourages sharing and tagging (@codydarkland)
