Building Games with Claude and CLI AI Agents

Step 1: Install Claude Code and Initialize Your Project

Claude Code installs through npm with a global package install. Once installed, navigate to your game project directory in the terminal and start a session. On first run, the agent indexes your project structure, reading file names, directory organization, and key configuration files to build its understanding of your codebase.

The initial session is a good time to ask the agent to summarize what it understands about your project. Ask it to describe the architecture, list the major systems, and identify the entry points. This confirms that the agent has correctly parsed your project and gives you a baseline for the quality of its understanding. If it mischaracterizes something, that tells you what to clarify in your CLAUDE.md file.

Claude Code works with any programming language and game engine. It handles TypeScript and JavaScript web game projects, GDScript for Godot, C# for Unity scripts, C++ for Unreal, and Rust for Bevy or custom engines. The agent adapts its suggestions to the language and framework it detects in your project.

Step 2: Write a CLAUDE.md for Your Game Project

The CLAUDE.md file is the primary way you communicate project context to Claude Code. Place it in your project root, and the agent reads it automatically at the start of every session. For game projects, this file should contain your engine and version, project architecture, build and run commands, testing approach, and coding conventions.

Start with the basics: "This is a Babylon.js 7 web game using TypeScript. The game is a city builder with isometric camera, tile-based terrain, and entity-component architecture." This single sentence gives the agent engine context, genre context, and architecture context that shapes every interaction.

Document your directory structure at a high level. List the major directories and what each contains: "src/engine/ contains the core game loop, renderer, and input system. src/entities/ contains entity definitions and components. src/world/ contains terrain generation and world state. src/ui/ contains the HUD and menu systems." The agent uses this map to find relevant code when implementing features.

Include build and run commands. "Build with npm run build. Start dev server with npm run dev. Run tests with npm test. The game runs at localhost:3000." Claude Code can execute these commands to verify its work, so accurate build instructions let it catch errors immediately rather than leaving them for you to discover.

Add constraints that prevent common mistakes. "Never modify the TileRenderer directly, all rendering changes go through the RenderQueue. Physics updates must happen in the fixedUpdate() method, not update(). Asset paths are relative to the public/ directory." These rules prevent the agent from generating code that compiles but breaks your architecture.

Claude Code also supports nested CLAUDE.md files in subdirectories. For large game projects, a CLAUDE.md in src/physics/ can describe the physics system's specific conventions without cluttering the root file. The agent reads the most specific CLAUDE.md file relevant to the files it is currently working on.

Step 3: Describe Game Features in Natural Language

When you ask Claude Code to build something, specificity determines output quality. Game development prompts should reference your existing code by name, specify the engine APIs to use, and describe the desired gameplay behavior concretely.

A weak prompt: "Add a dash ability to the player." A strong prompt: "Add a dash ability to the PlayerController class. When the player presses Shift and a movement direction, apply an instant velocity impulse of 15 units in the movement direction. The dash should have a 1.5 second cooldown tracked by the CooldownSystem. During the dash (0.2 seconds), disable gravity and reduce collision response. Use the existing InputManager.getAction() pattern for input detection."

The strong prompt references specific classes (PlayerController, CooldownSystem, InputManager), specifies exact parameters (15 units, 1.5 seconds, 0.2 seconds), describes the behavior in game design terms (disable gravity, reduce collision response), and names the patterns to follow (InputManager.getAction()). The agent can now read those existing classes and generate code that fits.

For complex features, provide context about why you want the feature and how it fits into the larger game design. "We need a fog of war system because the game is a real-time strategy where information asymmetry is a core mechanic. Tiles should be in one of three visibility states: unexplored (black), explored but not visible (dark grey, shows terrain but not units), and visible (full rendering). Visibility is determined by unit sight ranges calculated in the VisionSystem." This design context helps the agent make appropriate implementation choices.

Step 4: Let the Agent Plan and Execute Multi-File Changes

Claude Code reads relevant files before writing any code. For a feature that touches your entity system, rendering pipeline, and input handling, the agent will read those files first to understand your existing patterns. It then presents a plan describing which files it will create or modify and what changes it will make.

Review the plan before approving execution. Check that the agent identified the right files, that its approach matches your architecture, and that it is not planning to modify files it should not touch. For game code where a wrong edit can break physics, rendering, or save systems, plan review prevents costly mistakes.

As the agent writes code, it creates or modifies files and shows you the changes. For game projects, pay attention to whether the agent is following your established patterns. If your entity components all implement a specific interface and the agent creates a component that does not, catch it early and provide feedback.

Multi-file features are where Claude Code truly outperforms autocomplete tools. Adding a new entity type that requires a component definition, a renderer, a serialization handler, a factory function, and a spawn point in the level editor is a five-file change that the agent handles as a single coherent task. Each file's changes are consistent with the others because the agent plans them together.

Step 5: Use Extended Thinking for Complex Game Algorithms

Extended thinking is a mode that gives the AI more reasoning time before generating code. For game development, this helps with algorithmic challenges where the naive solution is wrong or too slow and the correct approach requires careful analysis.

Pathfinding implementations benefit from extended thinking. Asking for "A* pathfinding on a hexagonal grid with variable terrain costs, unit sizes larger than one hex, and dynamic obstacle avoidance" requires the agent to reason about hex coordinate systems, the heuristic function for hex grids, how to handle multi-hex units, and how dynamic obstacles affect path validity. Extended thinking lets the agent work through these considerations before committing to an implementation.

Procedural generation algorithms are another strong use case. "Generate a dungeon layout using binary space partitioning with guaranteed connectivity, room size variance between 4x4 and 12x12 tiles, corridors that follow cardinal directions, and placement hooks for entrance, exit, and boss rooms" involves multiple interacting constraints that benefit from upfront reasoning.

Physics calculations, optimization problems, and state machine designs with complex transition rules all benefit from extended thinking. The trade-off is that the agent takes longer to respond, but for algorithmic code that needs to be correct on the first pass, the extra reasoning time is worthwhile.

Step 6: Run Build Tools and Tests Through the Agent

Claude Code can execute terminal commands as part of its workflow. After writing game code, it can run your TypeScript compiler to check for type errors, execute your build tool to verify bundling works, run your test suite to catch regressions, and even start your development server to confirm the game loads.

This capability is especially valuable for game projects with complex build pipelines. If your game uses a bundler with specific configuration, shader compilation steps, asset processing, or platform-specific build targets, the agent can run the full pipeline and react to any errors by fixing its generated code.

For test-driven game development, you can ask the agent to write tests alongside the feature code. "Add a DamageCalculation module with tests that verify: base damage equals weapon damage minus armor, critical hits multiply by 2.5, fire damage ignores 50% of armor, and damage cannot go below 1." The agent writes both the module and the test file, then runs the tests to verify everything passes.

When the build or tests fail, the agent reads the error output and attempts to fix the issues. This feedback loop of write, build, fix is particularly productive for game code where compile-time type checking catches many errors that would otherwise only appear at runtime.

Step 7: Iterate on Gameplay Code with Targeted Follow-ups

After generating and testing code, you will run your game and observe the actual behavior. Game code needs iteration based on how it feels and plays, not just whether it compiles. Use targeted follow-up prompts to refine the generated code based on your playtesting observations.

Specific follow-ups work much better than vague ones. "The dash ability works but the player slides too far after dashing, add ground friction that ramps up over 0.1 seconds after the dash ends, and prevent dashing while already in a dash state" gives the agent concrete adjustments to make. The agent reads the current dash code, understands its structure, and makes minimal changes to address your feedback.

For visual and gameplay feel issues, describe what you observe and what you want instead. "The projectile spawns at the player's center but it should appear at the weapon tip, offset 1.2 units forward and 0.3 units up in the player's local space" gives precise spatial information the agent can translate directly into code.

Claude Code maintains context across a conversation, so each follow-up builds on the previous state. You can have a multi-turn conversation where you progressively refine a feature: first the basic behavior, then the edge cases, then the visual polish, then the performance optimization. The agent remembers all previous changes and adjustments.