Claude Code has become one of the most popular AI development tools in 2026, and for good reason. It's a terminal-based AI assistant that can read your project files, execute commands, and — most importantly for game developers — connect to MCP servers that give it direct access to your game engine and 3D tools.

But most Claude Code setup guides are written for web developers. They focus on JavaScript, React, and REST APIs. Game development has different needs: you're working with binary project files, visual editors, real-time applications, and specialized tools that web developers never touch.

This guide is specifically for game developers. We'll cover everything from installation through advanced configuration, with a focus on the workflows that matter for Unreal Engine and Blender development. Whether you're a solo indie developer or part of a small studio, this guide will get you from zero to productive.

What Is Claude Code?

If you're completely new to Claude Code, here's the short version: it's an AI assistant that runs in your terminal. You type natural language instructions, and Claude executes them — reading files, running commands, making edits, and interacting with external tools through MCP.

For game developers, the key difference between Claude Code and other AI tools (ChatGPT, Copilot, etc.) is the MCP integration. Claude Code doesn't just generate text or code that you copy and paste. Through MCP, it can directly interact with a running instance of Unreal Engine or Blender, executing operations in your editor as you describe them.

This means you can say "place a directional light angled for sunset and set its intensity to 8.0" and the light appears in your Unreal viewport. No copying code. No finding the right menu. No manual property editing. The AI talks directly to your editor through the MCP protocol.

Why Claude Code Over Other AI Clients?

Claude Code is not the only MCP-compatible client. Cursor, Windsurf, and Cline also support MCP. Here's why we recommend starting with Claude Code for game development:

Terminal-native — Claude Code runs in your terminal, leaving your screen space for the Unreal Editor or Blender viewport. You don't need to split screen with an IDE you're not using for game development.

Project context — Claude Code automatically reads your project structure, configuration files, and source code. When you ask about your project, it already knows the layout.

Agent capabilities — Claude Code supports sub-agent spawning, which enables parallel workflows. More on this later, but it's a game-changer for complex tasks.

Headless operation — Claude Code can run scripts and automated workflows without a GUI, which is useful for build pipelines and automated testing.

MCP first-class support — as an Anthropic product, Claude Code has the most mature and reliable MCP implementation. It's the reference client for the protocol.

That said, Cursor and Windsurf are excellent choices if you also write significant amounts of code (C++, Blueprints, shaders) and want AI assistance integrated directly into a code editor. Many developers use Claude Code for editor-side workflows and Cursor for code-side workflows.

Installation

Let's get Claude Code installed. The process is straightforward but varies slightly by operating system.

Prerequisites

Before installing Claude Code, ensure you have:

• Node.js 18 or later — Claude Code is distributed as an npm package. If you don't have Node.js, download it from nodejs.org or use a version manager like nvm.
• A terminal — on Windows, we recommend Windows Terminal with PowerShell or WSL2. On macOS, the default Terminal or iTerm2. On Linux, any terminal emulator.
• An Anthropic account with a Claude Pro or Claude Max subscription — Claude Code requires an active subscription. The Pro plan works, but Max gives you higher usage limits that are useful for intensive game development sessions.

Installing on Windows

Open your terminal (Windows Terminal recommended) and run:

npm install -g @anthropic-ai/claude-code

After installation completes, verify it:

claude --version

You should see the version number printed. If you get a "command not found" error, your npm global bin directory isn't in your PATH. Fix this by running:

npm config get prefix

Then add the displayed path plus /bin (or just the path on Windows, since npm puts executables directly in the prefix directory) to your system PATH.

Installing on macOS

The same npm command works:

npm install -g @anthropic-ai/claude-code

If you encounter permission errors, don't use sudo. Instead, configure npm to use a user-local directory:

mkdir ~/.npm-global
npm config set prefix '~/.npm-global'

Then add ~/.npm-global/bin to your PATH in your shell configuration file (.zshrc for macOS Ventura and later).

Installing on Linux

Same process:

npm install -g @anthropic-ai/claude-code

Linux users are likely familiar with PATH configuration. Ensure the npm global bin directory is in your PATH.

First Run

Navigate to your game project directory and start Claude Code:

cd /path/to/your/project
claude

On first run, Claude Code will:

1. Ask you to authenticate with your Anthropic account (opens a browser window)
2. Scan your project directory to understand the project structure
3. Present you with a prompt where you can start typing instructions

You should see something like:

Claude Code v1.x.x
Connected to Claude. Project: YourProjectName
Type /help for available commands.

>

That's it. Claude Code is running and ready. But before we start using it for game development, we need to configure MCP servers.

Configuring MCP Servers for Game Development

Claude Code on its own can read files, run commands, and help with code. But for game development, the real power comes from connecting MCP servers that give Claude direct access to your game engine and 3D tools.

Understanding MCP Configuration

MCP servers are configured in a JSON file. Claude Code looks for this configuration in several locations, in order of priority:

1. Project-level: .claude/mcp.json in your project directory
2. User-level: ~/.claude/mcp.json in your home directory

Project-level configuration is preferred because it travels with your project and can be shared with team members (though you should gitignore it if it contains any sensitive information).

Setting Up the Unreal MCP Server

The Unreal MCP Server connects Claude to a running instance of Unreal Editor. Here's the setup process:

Step 1: Install the Unreal MCP Server plugin

Download the plugin from your StraySpark account and install it in your Unreal project. Copy the plugin folder to your project's Plugins directory:

YourProject/
  Plugins/
    UnrealMCPServer/
      ...

Launch Unreal Editor with your project. The MCP Server plugin should appear in your plugins list (Edit > Plugins). Ensure it's enabled.

Step 2: Verify the MCP Server is running

With the plugin enabled, the MCP server starts automatically when the editor launches. You can verify it's running by checking the Output Log for a message like:

MCP Server: Listening on stdio

Step 3: Configure Claude Code

Create the MCP configuration file for your project:

mkdir -p .claude

Then create .claude/mcp.json with the following content:

{
  "mcpServers": {
    "unreal": {
      "command": "path/to/your/project/Plugins/UnrealMCPServer/Server/start.sh",
      "args": []
    }
  }
}

On Windows, use the .bat file instead:

{
  "mcpServers": {
    "unreal": {
      "command": "path\\to\\your\\project\\Plugins\\UnrealMCPServer\\Server\\start.bat",
      "args": []
    }
  }
}

Step 4: Restart Claude Code

Stop Claude Code (Ctrl+C or type /exit) and restart it:

claude

On startup, Claude Code will connect to the configured MCP servers. You should see a message indicating the Unreal MCP Server is connected and listing the available tool count.

Step 5: Test the connection

Type a simple command to verify everything works:

List all actors in the current level

Claude should respond with a list of actors from your currently open Unreal level. If this works, your MCP connection is live.

Setting Up the Blender MCP Server

The Blender MCP Server follows a similar pattern. Install the Blender add-on, configure the MCP connection in Claude Code, and verify.

Step 1: Install the Blender add-on

Download the Blender MCP Server add-on from your StraySpark account. In Blender, go to Edit > Preferences > Add-ons > Install, and select the downloaded .zip file. Enable the add-on.

Step 2: Start the MCP server in Blender

With the add-on enabled, find the MCP Server panel in Blender's sidebar (N panel). Click "Start Server" to begin listening for connections.

Step 3: Add to Claude Code configuration

Update your .claude/mcp.json to include both servers:

{
  "mcpServers": {
    "unreal": {
      "command": "path/to/UnrealMCPServer/Server/start.sh",
      "args": []
    },
    "blender": {
      "command": "path/to/BlenderMCPServer/server/start.sh",
      "args": []
    }
  }
}

Step 4: Restart and verify

Restart Claude Code and test the Blender connection:

List all objects in the current Blender scene

With both servers configured, Claude Code can operate in both Unreal Engine and Blender simultaneously. This enables cross-tool workflows like "create a cube mesh in Blender, UV unwrap it, export as FBX, and import into the open Unreal project."

Connecting Additional MCP Servers

Beyond game engine and DCC tool servers, you might want to connect other MCP servers for your workflow. Common additions for game developers:

Version control — if your team uses Perforce, there are community MCP servers that allow Claude to check out files, submit changelists, and manage branches. For Git users, Claude Code has built-in git support, so a separate MCP server isn't necessary.

Project management — MCP servers for Jira, Linear, Notion, and other project management tools let Claude create and update tasks as part of development workflows.

Documentation — connecting a documentation server lets Claude read your game design documents, technical specs, and wiki pages for context when making decisions.

Each additional server follows the same pattern: install the server, add its configuration to .claude/mcp.json, restart Claude Code.

Configuring Claude Code for Game Dev Workflows

With MCP servers connected, let's configure Claude Code itself for optimal game development use.

The CLAUDE.md File

Claude Code reads a special file called CLAUDE.md in your project root (if it exists) to understand project-specific context. For game projects, this file is extremely valuable. Create it with information that helps Claude understand your project:

# Project Context

This is a third-person action RPG built in Unreal Engine 5.5.

## Project Structure
- /Content/Maps/ - Game levels
- /Content/Characters/ - Character assets and Blueprints
- /Content/Environment/ - Environment art and materials
- /Content/UI/ - UMG widget Blueprints
- /Source/ - C++ source code

## Naming Conventions
- Blueprints: BP_PascalCase (e.g., BP_PlayerCharacter)
- Materials: M_PascalCase (e.g., M_RockSurface)
- Material Instances: MI_PascalCase
- Textures: T_PascalCase_Suffix (T_Rock_D for diffuse, T_Rock_N for normal)
- Static Meshes: SM_PascalCase
- Skeletal Meshes: SK_PascalCase

## Current Sprint Focus
- Boss arena level (Maps/L_BossArena)
- Combat feel improvements
- Performance optimization for outdoor levels

## Performance Targets
- 60 fps on RTX 4070 at 1440p
- 30 fps minimum on GTX 1070

## Important Notes
- We use Nanite for all environment meshes
- Lumen is our GI solution (software ray tracing)
- The project uses World Partition for the open world level

Claude reads this file at the start of every session and uses it as context for all operations. The more specific your CLAUDE.md, the better Claude's decisions will be.

Custom Slash Commands

Claude Code supports custom slash commands defined in your project. Create a .claude/commands/ directory and add Markdown files for frequently used workflows:

.claude/commands/setup-level.md:

Set up a new game level with our standard configuration:
1. Create a new level at the specified path
2. Add a directional light (Sun) with intensity 10, rotation (-45, 30, 0)
3. Add a Sky Atmosphere actor
4. Add a SkyLight with intensity 1.0, real-time capture enabled
5. Add an ExponentialHeightFog actor with default settings
6. Add a PostProcessVolume marked as Infinite Extent with our standard settings:
   - Auto Exposure min/max: 1.0/1.0
   - Bloom intensity: 0.5
   - Vignette intensity: 0.3
7. Save the level

Now you can type /setup-level L_NewArena in Claude Code and it'll execute the full setup sequence through MCP.

.claude/commands/audit-performance.md:

Run a performance audit on the current level:
1. Get total actor count and report by class
2. Check for any actors with tick enabled that shouldn't be ticking
3. Report triangle count for the viewport
4. Check for any lights with overlapping attenuation radii
5. Report the number of draw calls
6. Flag any materials with more than 200 instructions
7. Check for any textures larger than 4096x4096
8. Summarize findings with optimization recommendations

Custom commands are a powerful way to standardize workflows across your team. Everyone uses the same setup processes, the same audit checks, and the same quality gates.

Memory and Context Management

Claude Code has a large context window but it's not infinite. For game projects with thousands of files, you'll want to manage what Claude pays attention to:

Use .claudeignore — similar to .gitignore, this file tells Claude Code which directories and files to skip when scanning your project. For Unreal projects, you almost always want to ignore:

# .claudeignore
Binaries/
Intermediate/
Saved/
DerivedDataCache/
.vs/
*.uasset
*.umap

This prevents Claude from trying to read binary files and generated content that would waste context and confuse analysis.

Be specific in your prompts — instead of "look at the player character code," say "look at Source/Characters/PlayerCharacter.cpp." Specific references help Claude find the right files immediately instead of searching through your entire project.

Use sessions wisely — Claude Code maintains context within a session. For complex workflows that build on each other (like iterating on a level's layout), keep the same session open. For unrelated tasks, start a new session to avoid confusing context.

Setting Up Agent Teams for Game Development

One of Claude Code's most powerful features for game development is sub-agent spawning. You can define specialized agents that focus on specific aspects of your project, then orchestrate them from the main Claude Code session.

What Are Agent Teams?

Agent teams are a pattern where you use Claude Code's ability to spawn sub-tasks, each focused on a specific domain. Instead of one AI assistant trying to be an expert at everything, you have specialized agents:

• A level design agent that focuses on actor placement, lighting, and scene composition
• A performance agent that focuses on profiling, optimization, and quality settings
• A asset pipeline agent that focuses on Blender-to-Unreal workflows
• A code review agent that focuses on C++ and Blueprint quality

Each agent has access to the same MCP servers but operates with focused context and instructions.

Configuring Agent Teams

You define agent teams through Claude Code's task system. Here's how to set up a practical game dev agent team:

In your CLAUDE.md, define the team roles:

## Agent Roles

When working on complex tasks, use these specialized approaches:

### Level Design Tasks
Focus on actor placement, lighting, post-processing, and scene composition.
Use the Unreal MCP tools for all editor operations.
Always check that new actors follow our naming conventions.
Save the level after significant changes.

### Performance Tasks
Start by profiling before making changes.
Focus on frame time, draw calls, triangle count, and memory usage.
Document all changes and their measured impact.
Never sacrifice gameplay-critical features for performance.

### Asset Pipeline Tasks
Use both Blender and Unreal MCP tools.
Follow our naming conventions for exports.
Verify Nanite compatibility for environment meshes.
Check UV layouts before export.

This context helps Claude Code adopt the right mindset when you describe tasks in terms of these roles.

Practical Agent Workflow Example

Here's how a multi-agent workflow might look in practice:

I need to set up the forest clearing for the merchant encounter.
This involves three tasks that can happen in parallel:

1. Level design: Place a clearing of about 30m diameter.
   Add ambient lighting appropriate for a dense forest with
   a gap in the canopy. Place a merchant cart at the center.

2. Performance: Once the level design task places the actors,
   profile the scene and check that we're within budget.
   The forest level is currently at 14ms GPU,
   and we need to stay under 16ms.

3. Asset check: Verify that all meshes used in the clearing
   are Nanite-enabled and have proper LOD fallbacks for
   non-Nanite hardware.

Claude Code can execute these as sub-tasks, using MCP tools for each. The level design work happens through the Unreal MCP Server (placing actors, configuring lights), the performance work uses profiling tools, and the asset check uses property inspection tools.

Your First Practical Workflows

With everything set up, let's walk through some practical first workflows to build your confidence with Claude Code for game development.

Workflow 1: Scene Setup from Description

This is the simplest and most immediately satisfying workflow. Describe a scene and watch it appear in your Unreal viewport:

Create a small indoor room for testing combat. The room should be:
- 15m x 10m x 4m (length x width x height)
- Use BSP brushes for walls, floor, and ceiling
- One directional light through a window opening (2m x 2m)
  on the long wall
- A point light in the center of the room, warm color,
  intensity 5000
- A few box meshes (1m cubes) scattered as cover objects

Claude will execute a series of MCP tool calls to create each element. You'll see actors appearing in your viewport in real time. If something doesn't look right, you can iterate:

Move the cover boxes closer to the walls, and add two more
near the center. Also, the point light is too bright -
reduce it to 2000.

Workflow 2: Batch Asset Configuration

This workflow saves the most time in day-to-day development. Instead of manually configuring dozens of assets one by one:

Find all Static Mesh actors in the current level that use
meshes from the /Content/Environment/Rocks/ folder.
For each one:
- Enable Nanite if it's not already enabled on the mesh
- Set cast shadow to true
- Set mobility to Static
- Enable "Affect Distance Field Lighting"
Report how many actors were modified.

This kind of batch operation would take 15-30 minutes of clicking through property panels in the editor. Through MCP, it takes seconds.

Workflow 3: Lighting Iteration

Lighting is one of the most iterative aspects of level design. Claude Code makes the iteration cycle faster:

The current lighting in this indoor scene feels too flat.
I want more dramatic lighting with deeper shadows.
Adjust the existing lights:
- Reduce the ambient/sky light intensity by 40%
- Increase the main directional light intensity by 20%
- Add a subtle blue fill light from the opposite direction
  of the main light, intensity about 10% of the main light
- Add a warm point light near the fireplace area with
  a 5m attenuation radius

After seeing the results in the viewport, you can continue iterating:

Better, but the fill light is too blue. Make it a more neutral
cool tone. And the fireplace light needs to be more orange,
not yellow.

Workflow 4: Blueprint Property Configuration

If you're working with Blueprints, Claude can read and modify their default properties through MCP:

Open BP_EnemyWarrior and update these defaults:
- MaxHealth: 150 (was 100)
- MovementSpeed: 450 (was 400)
- AttackDamage: 25 (was 20)
- AttackRange: 200 (was 150)
- AggroRange: 1500 (was 1000)

Also set these same values on BP_EnemyWarrior_Elite,
but multiply health by 2 and damage by 1.5.

Workflow 5: Cross-Tool Pipeline

If you have both the Unreal and Blender MCP servers configured, try a cross-tool workflow:

In Blender:
1. Create a simple wooden crate mesh (1m cube with beveled edges)
2. UV unwrap it
3. Apply a basic wood material
4. Export as FBX to /tmp/SM_WoodenCrate.fbx

Then in Unreal:
1. Import the FBX to /Content/Environment/Props/
2. Enable Nanite on the imported mesh
3. Place an instance in the current level at position (0, 0, 50)

This workflow spans two applications through a single conversation. Claude uses the Blender MCP Server for the modeling steps and the Unreal MCP Server for the import and placement steps.

Tips and Tricks

After months of using Claude Code for game development and supporting other developers doing the same, here are the tips that make the biggest difference.

Be Specific About Coordinates

When placing objects, always specify coordinates or relative positions. "Place a light near the door" is ambiguous. "Place a point light at (1200, -340, 300), which is above the main entrance" is clear.

Use the Undo Safety Net

Every operation Claude performs through the Unreal MCP Server integrates with the editor's undo system. If something goes wrong, Ctrl+Z in the editor reverts the AI's changes. This makes experimentation safe — you can try aggressive changes knowing you can always undo.

Save Frequently

Ask Claude to save the level after significant changes. While undo works for reverting mistakes, a saved checkpoint is your safety net against crashes or session disconnects:

Save the current level

Reference Existing Actors by Name

When modifying existing scene elements, reference them by their actor name in the Outliner:

Select the actor named "DirectionalLight_Sun" and change
its rotation to (-60, 45, 0)

This is more reliable than descriptions like "the main sun light" which Claude might misidentify.

Chain Operations with Context

Claude Code maintains context within a session, so you can build on previous operations:

> Place 5 point lights along the corridor, evenly spaced, warm color
[Claude places the lights]

> Those look good. Now duplicate that arrangement but shift it
> to the parallel corridor 10m to the east
[Claude duplicates and repositions]

> Great. Reduce the intensity of all 10 lights by 30%
[Claude adjusts all lights it previously placed]

Use Natural Language for Complex Math

Instead of calculating exact positions yourself:

Place spotlights in a circle of radius 8m around the arena center,
all pointing inward, spaced every 45 degrees. That should be 8 lights.

Claude handles the trigonometry and places each light at the correct position with the correct rotation.

Profile Before and After

When making optimization changes, always ask Claude to profile before the change, then after. This gives you concrete numbers:

Profile the current scene, then disable shadow casting on all
meshes smaller than 50cm, then profile again and compare

Advanced Configuration

Once you're comfortable with the basics, these advanced configurations will make Claude Code even more effective for game development.

Environment Variables for MCP

Some MCP servers accept configuration through environment variables. You can set these in your MCP configuration file:

{
  "mcpServers": {
    "unreal": {
      "command": "path/to/start.sh",
      "args": [],
      "env": {
        "MCP_LOG_LEVEL": "info",
        "MCP_TIMEOUT": "30000"
      }
    }
  }
}

The MCP_TIMEOUT variable is particularly useful for operations that take longer than the default timeout — things like importing large assets, building lighting, or running extended profiling passes.

Multiple Project Configurations

If you work on multiple game projects, you can maintain separate MCP configurations for each. Each project has its own .claude/mcp.json with paths specific to that project's plugin installation. When you cd to a different project and start Claude Code, it picks up that project's configuration automatically.

For shared team configurations, consider keeping a template MCP configuration in your version control system and having each developer copy and customize the paths for their local setup:

project-root/
  .claude/
    mcp.json.template    # tracked in VCS
    mcp.json             # local copy, gitignored
    commands/            # tracked in VCS
      setup-level.md
      audit-performance.md
      cleanup-scene.md

Configuring Claude's Behavior for Game Dev

Beyond the CLAUDE.md file, you can influence Claude's behavior through prompt patterns. Some patterns that work well for game development:

Confirmation before destructive operations: Add to your CLAUDE.md:

Always confirm before: deleting actors, removing components,
changing level streaming settings, or modifying persistent
level properties. List what will be changed and wait for approval.

Automatic documentation: Add to your CLAUDE.md:

After completing any level design task, add a comment to the
level's description noting what was added/changed and the date.

Quality gates: Add to your CLAUDE.md:

Before saving any level after modifications, run a quick
performance check. If frame time exceeds 16ms, warn me
before saving.

These behavioral instructions shape how Claude approaches every task in your project, creating guardrails that prevent common mistakes.

Integrating with Build Systems

Claude Code can interact with your project's build system through standard bash commands. For Unreal projects, useful build-system integrations include:

Cooking content:

Run the cook command for Windows target and report any errors

Building the project:

Build the project in Development Editor configuration
and report if there are any errors or warnings

Running automated tests:

Run all unit tests in the Combat module and report results

These aren't MCP operations — they're standard command-line operations that Claude Code handles natively. Combined with MCP for editor operations, you get comprehensive project automation through a single interface.

Remote MCP Servers

For studios where the Unreal Editor runs on a powerful workstation but developers sometimes work from laptops, MCP supports remote connections through HTTP/SSE transport. The configuration changes slightly:

{
  "mcpServers": {
    "unreal-remote": {
      "url": "http://workstation-ip:8080/mcp",
      "transport": "sse"
    }
  }
}

This lets you run Claude Code on your laptop while the MCP server communicates with Unreal Editor running on your workstation. The latency increase is minimal for most operations (a few milliseconds per tool call), and it means you can work from anywhere on your local network.

Common Issues and Solutions

Issue: MCP Connection Fails on Startup

Symptom: Claude Code starts but reports that the MCP server couldn't connect.

Solution: Ensure the target application (Unreal Editor or Blender) is running and the MCP server/add-on is active before starting Claude Code. The MCP server needs to be listening before Claude Code tries to connect.

Issue: Claude Makes Changes to the Wrong Level

Symptom: Claude modifies actors in a sub-level when you intended changes in the persistent level, or vice versa.

Solution: Be explicit about which level you're targeting. Start operations with "In the level L_BossArena..." or "In the currently active level..." to avoid ambiguity.

Issue: Operations Are Slow

Symptom: MCP tool calls take several seconds each, making workflows feel sluggish.

Solution: This is usually caused by the editor being under heavy load (compiling shaders, building lighting, etc.). Wait for background tasks to complete before starting MCP workflows. Also check that your Unreal project doesn't have excessive tick operations that slow down the editor.

Issue: Claude Doesn't Know About Project-Specific Assets

Symptom: Claude suggests using assets or Blueprints that don't exist in your project.

Solution: Claude doesn't automatically know every asset in your content browser. When referencing project-specific assets, provide the full content path: "Use the material at /Content/Materials/M_StoneWall" rather than "use the stone wall material."

Issue: Context Window Fills Up in Long Sessions

Symptom: Claude starts forgetting earlier parts of the conversation or making mistakes about previous operations.

Solution: For very long sessions, start a new Claude Code session periodically. Copy any important context (current goals, recent changes) into the new session's first prompt. Also ensure your .claudeignore is properly configured to prevent Claude from loading unnecessary files.

Issue: MCP Server Crashes During Complex Operations

Symptom: The MCP connection drops mid-workflow, requiring a restart.

Solution: This is rare but can happen during very large operations (modifying thousands of actors, importing massive assets). Break large operations into smaller batches. Instead of "modify all 5000 meshes in the level," do "modify the meshes in the ForestZone_A collection" and then proceed to the next collection.

What's Next

With Claude Code set up and configured for game development, here's a suggested learning path:

1. Spend a week on basic workflows — scene setup, actor placement, lighting iteration. Get comfortable with the conversation flow and learn when Claude needs more specific instructions.

2. Try batch operations — this is where you'll see the biggest productivity gains. Asset configuration, property changes across multiple actors, naming convention enforcement.

3. Explore cross-tool workflows — if you use both Blender and Unreal, start experimenting with asset pipeline workflows that span both tools.

4. Set up custom commands — identify your most repeated workflows and create custom slash commands for them.

5. Read our other tutorials — we've written extensively about specific MCP workflows:

   • AI-Assisted Level Design — comprehensive guide to using MCP for level design
   • 10 Things AI Can Do in Your Game Engine — practical use cases
   • Blender MCP Workflows — Blender-specific workflows
   • MCP vs Manual Scripting — understanding when to use MCP vs traditional scripting

6. Explore our other UE5 tools — Claude Code works alongside our traditional UE5 plugins. The Procedural Placement Tool handles rule-based environment scatter, the Cinematic Spline Tool provides professional camera systems, and the Blueprint Template Library gives you production-ready gameplay systems. These tools complement MCP workflows — use AI for configuration and iteration, use purpose-built tools for specialized features.

Claude Code is a tool, and like any tool, proficiency comes with practice. The setup is the easy part. The real value comes from developing an intuition for what to delegate to the AI, how to describe your intentions clearly, and when to take manual control. Give it a week of daily use, and you'll wonder how you worked without it.

Quick Reference

Here's a cheat sheet for the most common Claude Code operations in game development:

Starting a session:

cd /path/to/your/project && claude

Useful slash commands:

• /help — show available commands
• /exit — end the session
• /clear — clear conversation history
• /compact — condense the conversation to save context space

Essential first prompts:

• "List all actors in the current level" — verify MCP connection
• "What tools do you have available for Unreal?" — see MCP tool list
• "Save the current level" — always save after changes
• "Undo the last operation" — revert through MCP

MCP configuration location:

• Project: .claude/mcp.json
• User: ~/.claude/mcp.json

Custom commands location:

• .claude/commands/your-command.md

Project context file:

• CLAUDE.md in project root

Keep this guide bookmarked. As you develop your Claude Code workflow, you'll find yourself returning to specific sections — especially the MCP configuration and troubleshooting sections — as your setup evolves.