Unreal Engine 5.7 arrived with a headline feature that most game developers had been anticipating for over a year: an official, built-in AI Assistant panel. Epic had teased it at GDC, previewed it in early-access streams, and positioned it as the answer to "how do I use AI in my game development workflow?"

Now that the feature has been in production hands for several weeks, we can give an honest UE 5.7 AI assistant review — not based on demo reels, but based on actually trying to ship work with it. And we can compare it against the MCP (Model Context Protocol) approach that tools like our Unreal MCP Server use, along with third-party competitors like UnrealCopilot and Ludus AI.

The short version: they are different tools solving different problems. The longer version involves understanding what "AI assistance" actually means in the context of a game engine, where the built-in assistant excels, where it hits a wall, and why the Unreal AI assistant vs MCP conversation should really be about complementary workflows rather than replacement.

Let us walk through the entire landscape so you can build a decision framework that fits your project, your team size, and your actual needs.

What UE 5.7's AI Assistant Actually Does

Before comparing anything, we need to establish what the built-in AI Assistant panel is and is not. There has been a significant amount of hype and misunderstanding floating around forums and social media, so let us ground this in specifics.

The Architecture

UE 5.7's AI Assistant is a docked panel inside the editor — similar to the Output Log or Content Browser — that connects to a cloud-based LLM (currently powered by an Epic-hosted model, with options to connect your own API key for Claude or GPT-4). It has read access to your project structure, Blueprint graphs, C++ headers, and the engine documentation. It can see the currently selected actors, the open Blueprint graph, and the active level.

Critically, it is primarily a conversational assistant. You ask questions. It answers. You describe code. It generates. You point at a Blueprint node. It explains.

What the Built-In AI Assistant Handles Well

Let us give credit where it is due. For the following use cases, the built-in assistant is genuinely useful and often the fastest option:

Documentation lookup and explanation. Ask "What does the Lumen Global Illumination quality setting do?" and you get an accurate, context-aware answer that references the specific version you are running. This is faster than searching the docs manually, and the answers are tailored to 5.7 rather than showing outdated 4.x information.

Blueprint node explanation. Select a node in a Blueprint graph, ask "What does this do?" and the assistant explains the node, its inputs and outputs, and common use cases. For developers learning the engine, this is excellent. It is like having an experienced mentor looking over your shoulder.

Basic C++ and Blueprint code generation. Ask "Write a C++ function that traces from the player camera and returns the first hit actor" and you get a reasonable implementation. It understands the Unreal API, generates headers and implementations in the correct style, and usually produces code that compiles on the first try for straightforward requests.

Error diagnosis. Paste a compile error or Blueprint error, and the assistant can usually identify the problem and suggest a fix. It is especially good at catching common mistakes like missing UPROPERTY macros, incorrect delegate signatures, or forgetting to call Super in overridden functions.

Project-aware Q&A. Because it can see your project structure, you can ask questions like "Which Blueprints in my project use the EQS system?" and it will scan and answer. This project awareness is the biggest differentiator from using a standalone chatbot.

Where the Built-In Assistant Hits Its Limits

Here is where the honest assessment begins. The built-in assistant has clear boundaries that become apparent once you move past Q&A and basic code generation:

No editor automation. The assistant can tell you how to set up a material instance, but it cannot create one. It can explain how to configure a post-process volume, but it cannot add one to your level. It can generate Blueprint code as text, but it cannot paste it into a graph, connect nodes, or compile the Blueprint. This is the single biggest limitation.

No batch operations. If you need to rename 200 assets, configure LOD settings on 50 meshes, or set up collision on 30 static meshes, the assistant cannot help with execution. It can give you instructions for each one, but you still have to click through every operation manually.

No multi-step workflows. Complex tasks like "import these textures, create materials from them, assign them to the correct meshes, and set up LODs" require a chain of editor operations. The assistant can describe the workflow, but it cannot execute any step in it.

Single-tool scope. The assistant only knows about Unreal Engine. If your workflow involves Blender, Substance, Houdini, or any external tool, the assistant cannot bridge that gap. It lives entirely inside the UE editor.

Limited context window for large projects. While the assistant can see your project, it struggles with very large codebases. Asking about interactions between multiple subsystems can exceed what it can reason about, leading to incomplete or inaccurate answers.

No persistent memory across sessions. Each time you restart the editor, the assistant starts fresh. It does not remember previous conversations, your preferences, or patterns it learned about your project architecture.

What MCP-Based Solutions Actually Do

MCP — the Model Context Protocol — takes a fundamentally different approach. Instead of embedding an AI chatbot inside the editor, MCP exposes the editor's functionality as a structured tool API that external AI agents can call.

Our Unreal MCP Server provides 207 tools across 34 categories. Each tool corresponds to a specific editor operation: create an actor, modify a material, configure a light, set up a particle system, import an asset, rename a file, compile a Blueprint, execute a console command, and so on.

An AI assistant (Claude, Cursor, Windsurf, or any MCP-compatible client) connects to the server and can call these tools in sequence to execute complex, multi-step workflows. The key differences from the built-in assistant:

Deep Editor Automation

MCP does not just talk about what you could do — it does it. When you say "Create a point light at position 500, 200, 300 with intensity 8000 and color warm white," the MCP server calls the appropriate tool, the light appears in your viewport, and you can see and undo the result immediately.

This extends to everything the editor can do: creating actors, modifying properties, managing assets, configuring world settings, setting up materials, building lighting, running automation scripts, and more.

Batch Operations

MCP excels at repetitive operations. "Set all static meshes in /Game/Environment/ to use Nanite" is not a description of what you should do — it is an instruction that gets executed across every matching asset. The AI iterates through the assets, calls the appropriate tool for each one, and reports the results.

This is where the time savings become dramatic. Operations that would take hours of manual clicking happen in minutes.

Multi-Step Workflows

Because MCP tools can be chained, the AI can execute complex workflows autonomously. For example:

1. Import FBX files from a directory
2. Create material instances for each imported mesh
3. Assign textures to the correct material parameters based on naming conventions
4. Apply the materials to the meshes
5. Set up LOD configurations based on polygon count
6. Generate collision for each mesh
7. Place the meshes in the level at specified locations

Each step is a tool call. The AI handles the logic of connecting steps, interpreting results, and adjusting its approach if something unexpected happens (like a missing texture or a mesh that fails to import).

Cross-Tool Pipelines

MCP is not limited to a single application. If you are using our Blender MCP Server alongside the Unreal MCP Server, an AI agent can coordinate workflows across both tools. Model something in Blender, export it, import it into Unreal, set up materials, and place it in a level — all from a single conversation.

This cross-tool capability is something the built-in assistant simply cannot offer. It is one of the primary reasons why MCP-based solutions exist.

Feature-by-Feature Comparison

Let us lay this out in a structured comparison so you can see exactly where each approach wins:

The Competitor Landscape in 2026

The built-in assistant and MCP servers are not the only players. Let us briefly cover the other tools in this space so the comparison is complete.

UnrealCopilot

UnrealCopilot emerged in early 2025 as a plugin that embeds AI code completion directly into the Unreal Editor's code editing experience — both for C++ and Blueprint scripting. Think of it like GitHub Copilot, but specifically trained on the Unreal Engine API and aware of your project context.

Strengths: Fast inline code completion. Good at predicting the next line of C++ you are about to write. Blueprint scripting assistance that understands node connections. Relatively lightweight — does not try to control the editor, just helps you write code faster.

Weaknesses: Code-generation only. No editor automation whatsoever. No batch operations. No cross-tool pipelines. It is a productivity boost for writing code, not a workflow automation solution.

Best for: Developers who spend most of their time writing C++ or Blueprint script and want faster completion. It complements both the built-in assistant (for explanation) and MCP (for automation) without overlapping much.

Ludus AI

Ludus AI takes a different approach entirely. Rather than integrating into the editor, it is a standalone platform that uses AI to generate game design documents, prototype mechanics, and create game logic blueprints from natural language descriptions. It positions itself as a "game design AI" rather than an "editor AI."

Strengths: Rapid prototyping of game mechanics. Good at translating high-level design concepts into implementable specifications. Can generate Blueprint logic diagrams (though not executable Blueprints directly). Useful for pre-production and ideation.

Weaknesses: Not integrated into the editor. Generated outputs need manual implementation. Focused on design rather than production workflows. Cannot automate any editor operations. Limited understanding of your specific project context.

Best for: Solo developers and small teams in pre-production who want to rapidly explore game design ideas. Less useful once you are in production and need to execute on a known design.

How They All Fit Together

Here is the key insight: none of these tools replace each other. They operate at different layers of the development process:

• Ludus AI → Game design and pre-production ideation
• UnrealCopilot → Code writing acceleration (C++ and Blueprint scripting)
• UE 5.7 AI Assistant → Documentation, explanation, diagnosis, and basic code generation
• MCP (Unreal MCP Server) → Editor automation, batch operations, and cross-tool workflows

A developer could reasonably use all four in a single project without any redundancy. The question is not "which one should I pick?" but "which ones are worth the setup cost for my specific workflow?"

Practical Scenarios: When to Use What

Let us walk through real development scenarios and identify which tool is the best fit for each.

Scenario 1: Learning a New Engine Feature

You have never used World Partition in UE 5.7 and need to convert your existing level to use it.

Best tool: UE 5.7 AI Assistant.

This is a knowledge-acquisition task. You need explanations, step-by-step guidance, and answers to "what happens if I do X?" questions. The built-in assistant's project awareness means it can look at your actual level and give specific advice about your setup. MCP could technically help you execute the conversion steps, but you want to understand the feature first. Use the assistant to learn, then decide if you want to use MCP to automate any repetitive parts of the migration.

Scenario 2: Setting Up 150 Meshes with Correct LODs, Collision, and Nanite

You just received a batch of environment meshes from your art team (or generated them with AI art tools). They need proper LOD chains, collision volumes, and Nanite configuration before they are production-ready.

Best tool: MCP (Unreal MCP Server).

This is pure batch automation. You need the same series of operations applied to 150 assets with minor variations based on mesh complexity. The built-in assistant cannot execute any of these operations. UnrealCopilot does not handle asset configuration. The Unreal MCP Server can iterate through every mesh, apply the correct settings, and report any that need manual attention. What would take a full day manually happens in about 15 minutes.

Scenario 3: Debugging a Crash in Your Ability System

Your custom ability system crashes when two abilities trigger simultaneously. You have a call stack and a vague idea of where the problem is.

Best tool: UE 5.7 AI Assistant (primary) + UnrealCopilot (secondary).

The built-in assistant can analyze the crash log, explain the call stack, and suggest likely causes based on your code. It understands the engine's internal workings well enough to identify common concurrency issues. UnrealCopilot can help you write the fix once you identify it. MCP is not particularly useful here — debugging is a reasoning and knowledge task, not an automation task.

That said, if you do not have a custom ability system yet, you might consider using the Blueprint Template Library, which includes a production-ready abilities system that handles edge cases like simultaneous activation out of the box.

Scenario 4: Building a Complete Environment From Scratch

You need to create a forest clearing for your RPG. Trees, rocks, grass, flowers, a stream, ambient lighting, fog, particle effects, and a complete audio setup.

Best tool: MCP (with multiple tools in the pipeline).

This is a multi-step, cross-domain workflow. You could use the Blender MCP Server to set up tree variations using geometry nodes, export them via USD, use the Unreal MCP Server to import them and set up materials, then use the Procedural Placement Tool to scatter them across the terrain with biome-aware rules. MCP handles the pipeline. The built-in assistant could help you understand individual steps, but it cannot execute any of them.

Scenario 5: Quick One-Off Questions During Development

"What's the default collision channel for Pawns?" "How do I enable ray tracing reflections in 5.7?" "What's the syntax for a dynamic multicast delegate?"

Best tool: UE 5.7 AI Assistant.

For quick questions, the built-in assistant is unbeatable. It is right there in the editor, it knows the exact version you are using, and it responds in seconds. Spinning up an MCP conversation for a one-line question is overkill.

Scenario 6: Setting Up a Cinematic Camera Sequence

You need to create a flythrough camera for a trailer. Multiple camera angles, smooth transitions, depth of field adjustments, and filmback settings that match your target aspect ratio.

Best tool: MCP + Cinematic Spline Tool.

The Cinematic Spline Tool gives you a professional spline camera system with 17 filmback presets, and the MCP server can automate the setup of camera actors, post-process settings, and sequencer tracks. The built-in assistant could explain how Sequencer works, but it cannot create or configure the camera rig.

Scenario 7: Onboarding a New Team Member

A junior developer just joined your team and needs to understand your project architecture, coding standards, and existing systems.

Best tool: UE 5.7 AI Assistant.

The assistant can answer questions about your project specifically: "How is the inventory system structured?" "Which classes handle player input?" "What does this Blueprint do?" This interactive, exploratory learning experience is the assistant's strongest use case. MCP is designed for developers who already know what they want to do and need it done efficiently.

When the Built-In Assistant Is Enough

Let us be direct about this. For many developers, the built-in AI assistant might be all you need. Here are the profiles where the built-in assistant covers most of your AI workflow needs:

Learning-focused developers. If you are still learning Unreal Engine, the assistant is an incredible resource. It explains concepts, answers questions, generates example code, and helps you understand the engine. You do not need editor automation yet because you are still building understanding.

Small projects with manual scope. If your project has fewer than 50 unique meshes, a handful of materials, and a single developer, the manual work of setting up assets is manageable. The time investment in learning MCP might not pay off for a project of this scale.

Code-heavy workflows. If your work is primarily C++ or Blueprint scripting with minimal editor operations, the assistant plus UnrealCopilot covers most of your needs. You are writing code, not configuring hundreds of assets.

Hobby projects without deadlines. If you are not under time pressure, manual workflows are fine. The value of automation is primarily in time savings, and time pressure is what makes those savings meaningful.

When You Need MCP

Here are the profiles where MCP-based solutions become necessary or at least highly valuable:

Production-scale asset pipelines. Once you are dealing with hundreds of meshes, materials, textures, and Blueprints, manual configuration becomes a bottleneck. MCP turns hours of clicking into minutes of natural-language instructions.

Cross-tool workflows. If your pipeline involves Blender (or other DCC tools) and Unreal Engine, the ability to automate across both tools through a single conversation is a significant force multiplier. Our Blender MCP Server with 212 tools across 22 categories paired with the Unreal MCP Server creates a seamless pipeline.

Teams with standardization needs. When multiple people are working in the same project, MCP can enforce consistency. "Set up all new meshes according to our project standards" ensures every asset gets the same LOD settings, collision configuration, and naming convention regardless of who imported it.

Iterative environment design. If you are frequently rearranging, relighting, or reconfiguring levels, MCP lets you make sweeping changes quickly. "Move all point lights in this room up by 50 units and increase intensity by 20%" is a single instruction instead of selecting and modifying each light individually.

Tight deadlines. Game jams, demo deadlines, publisher milestones — any situation where you need to ship fast benefits from automation. MCP does not make you a faster artist or designer, but it eliminates the mechanical overhead between your creative decisions and their execution.

Solo developers wearing multiple hats. If you are doing art, code, design, audio, and production all by yourself, the cumulative time savings of MCP across all those disciplines adds up fast. You can focus your limited energy on creative decisions rather than repetitive editor operations.

Building Your AI Toolchain: A Decision Framework

Here is a practical framework for choosing which AI tools to adopt. Work through these questions in order:

Step 1: Assess Your Primary Bottleneck

Where do you actually spend most of your development time?

• Understanding the engine → Start with the built-in AI Assistant. It is free and immediately useful for learning.
• Writing code → Add UnrealCopilot for faster code completion.
• Editor operations (asset setup, level design, configuration) → This is where MCP adds the most value.
• Game design and prototyping → Consider Ludus AI for pre-production.

Step 2: Evaluate Your Project Scale

How many assets, materials, Blueprints, and levels does your project have (or will it have)?

• Under 100 unique assets → Manual workflows are fine. Built-in assistant for guidance.
• 100–500 unique assets → MCP starts paying for itself. The setup time is recovered within the first major batch operation.
• 500+ unique assets → MCP is almost essential. Manual configuration at this scale is a serious bottleneck.

Step 3: Consider Your Pipeline Complexity

How many tools are in your production pipeline?

• UE only → Built-in assistant covers most Q&A and guidance needs.
• UE + one DCC tool → MCP becomes valuable for bridging the tools.
• UE + multiple external tools → MCP's cross-tool capability is a significant advantage.

Step 4: Factor in Team Size

• Solo → You need efficiency everywhere. MCP's broad automation capability is most impactful for solo developers.
• Small team (2–5) → MCP helps with standardization and reducing the burden on your most technical team member.
• Larger teams → Each team member likely specializes. MCP is most valuable for environment artists, technical artists, and anyone doing batch operations. Programmers might prefer the code-focused tools.

Step 5: Be Honest About Your Budget

• Free tier only → UE 5.7 AI Assistant is included.
• Under $100 → A personal license for the Unreal MCP Server ($69.99) covers the most impactful automation use cases.
• Under $300 → Add the Blender MCP Server ($59.99) for cross-tool pipelines, or the Procedural Placement Tool ($49.99) for environment scatter workflows.
• Full toolkit → The combination of MCP servers, procedural tools, and template libraries creates a comprehensive AI-powered workflow that covers most production needs.

The Complementary Workflow in Practice

Let us walk through how a real development session looks when you use the built-in assistant and MCP together, rather than choosing one over the other.

Morning: Research and Planning

You are adding a weather system to your open-world game. You start by asking the built-in AI Assistant:

• "What approaches are available for dynamic weather in UE 5.7?"
• "How does the new volumetric cloud system handle precipitation?"
• "Can I drive material parameters from the sky atmosphere component?"

The assistant gives you detailed answers, references relevant documentation, and helps you sketch out an architecture. You learn that you will need a Weather Manager actor, volumetric cloud configuration, material parameter collections for wet surfaces, and particle systems for rain and snow.

Midday: Implementation

Now you switch to MCP. You have a clear plan and need to execute it:

"Create a Weather Manager actor class with these properties: CurrentWeatherState (enum), TransitionSpeed (float), RainIntensity (float, 0-1), CloudCoverage (float, 0-1). Create a material parameter collection named MPC_Weather with parameters WetnessFactor, PuddleAmount, FogDensity, and WindStrength."

The MCP server creates the actor, sets up the properties, creates the material parameter collection, and configures the parameters. Operations that would take 20 minutes of clicking through the editor are done in under a minute.

You continue: "Create a post-process volume at world center, set to Unbound, with volumetric fog enabled. Create a Niagara system in /Game/FX/Weather/ named NS_RainSystem. Set up a directional wind component on the Weather Manager with default strength 500."

Afternoon: Iteration and Polish

As you test the weather system, you notice that the rain particles look flat. You ask the built-in assistant: "Why do my Niagara particles look flat when viewed from the side? They're using sprite renderers." The assistant explains camera-facing sprites and suggests using mesh renderers or ribbon renderers for raindrops instead.

Then you use MCP to implement the change: "Switch the NS_RainSystem to use mesh renderers with an elongated capsule mesh aligned to velocity. Set the mesh scale to (0.02, 0.02, 0.15)."

Evening: Batch Operations

Before wrapping up, you realize your 40 outdoor materials all need a wetness overlay. Instead of opening each material and adding the logic manually:

"For all materials in /Game/Materials/Environment/Outdoor/, add a material parameter collection reference to MPC_Weather and multiply the base color by a lerp driven by the WetnessFactor parameter."

MCP iterates through all 40 materials, makes the modifications, and reports any that had issues (like materials that already had a wetness setup from an earlier prototype).

The Result

In a single day, you went from zero to a functional weather system with 40 updated materials. The built-in assistant handled the knowledge and design phase. MCP handled the execution. Neither tool could have done the entire job alone, but together they covered the full spectrum from "what should I build?" to "build it for me."

Common Objections and Honest Answers

"MCP is just a fancy script runner. I could write Python scripts to do the same thing."

Technically true. You could write Python automation scripts using Unreal's Python API. Many studios do exactly this. The difference is:

1. Natural language is faster than writing scripts. Describing what you want in English takes seconds. Writing, testing, and debugging a Python script takes minutes to hours.
2. MCP handles edge cases. The AI adapts to unexpected situations — a missing asset, a different folder structure, an unexpected property type. Scripts crash.
3. MCP is discoverable. You do not need to know the Python API to use it. You describe what you want, and the AI figures out which tools to call.
4. Scripts require maintenance. When Unreal updates its API, your scripts break. MCP tools are maintained and updated with each engine version.

That said, if your studio already has a mature Python automation pipeline, MCP is a complement, not a replacement. Use MCP for ad-hoc operations and your scripts for standardized, repeatable processes.

"The built-in assistant will eventually do everything MCP does."

Maybe. Epic could absolutely expand the assistant to include editor automation capabilities. But consider:

1. The built-in assistant is designed as a conversational tool. Adding execution capabilities changes its fundamental architecture. It is not a trivial extension.
2. MCP is an open protocol. It works with any AI client (Claude, GPT-4, Cursor, Windsurf) and any application that implements a server. The built-in assistant locks you into Epic's implementation and their choice of LLM.
3. MCP already exists and works today. Waiting for a feature that might come in UE 5.8 or 6.0 means losing months of productivity in the meantime.
4. Even if the built-in assistant adds automation, MCP offers cross-tool workflows. The assistant will likely never control Blender, Substance, or other external tools.

"I don't trust AI to modify my project."

A reasonable concern. Here is how MCP addresses it:

1. Everything goes through the editor's undo system. Any change can be reverted with Ctrl+Z, just like a manual edit.
2. The AI reports what it did. After each operation, you see exactly what was created, modified, or deleted. No hidden changes.
3. You control the scope. You can ask the AI to process one asset first, verify the result, and then proceed with the rest. Start small, build trust.
4. Version control is your safety net. If something goes badly wrong, your VCS catches it at commit time. This is no different from any other tool in your pipeline.

"This costs money. The built-in assistant is free."

The built-in assistant has a free tier with limited queries per day and access to a smaller model. The premium tier (which uses more capable models and removes query limits) requires an Epic AI subscription. MCP servers like the Unreal MCP Server are a one-time purchase. Over any meaningful time horizon, the cost is comparable, and MCP does not have recurring fees.

Looking Ahead: Where AI Tooling Is Going

The AI tooling landscape for game development is evolving rapidly. Here is what we expect to see over the next 12–18 months:

Deeper integration between approaches. The built-in assistant and MCP will likely become easier to use together. We would not be surprised if Epic exposes an MCP client in the editor alongside the assistant, allowing you to use both from a single interface.

More specialized AI tools. Rather than one AI doing everything, we expect a proliferation of focused tools — AI for animation, AI for audio, AI for materials, AI for testing. The challenge will be orchestrating them, which is where MCP's open protocol becomes increasingly valuable.

Better context management. Current AI tools struggle with very large projects because context windows have limits. Advances in context management — both from AI model improvements and from smarter tool design — will make AI more capable on production-scale projects.

Standardization around MCP. The Model Context Protocol is gaining adoption across industries, not just game development. As more tools support it, the ability to build cross-application AI workflows will become a standard expectation rather than a differentiator.

Our Recommended Toolchain for 2026

Based on everything we have covered, here is our recommended AI toolchain for different developer profiles:

Solo Indie Developer

1. UE 5.7 AI Assistant (free tier) — for learning and quick questions
2. Unreal MCP Server (personal license, $69.99) — for editor automation
3. Blender MCP Server (personal license, $59.99) — if your pipeline includes Blender

Total cost: $69.99–$129.98 one-time. This covers the vast majority of AI-assisted workflows a solo developer needs.

Small Studio (2–5 People)

1. UE 5.7 AI Assistant (premium tier) — for the whole team
2. Unreal MCP Server (studio license, $199.99) — shared across the team
3. Blender MCP Server (studio license, $179.99) — for artists
4. UnrealCopilot — for programmers
5. Procedural Placement Tool (studio license, $149.99) — for environment artists

Total cost: varies by team needs. Prioritize based on your team's bottlenecks.

Larger Studio

At this point, you likely have a technical art or pipeline team that evaluates tools formally. We recommend setting up a test project with each tool, measuring actual time savings on representative tasks, and making a data-driven decision. The built-in assistant is a no-brainer for everyone. MCP tools should be evaluated by the team members who do the most editor operations.

Conclusion

The UE 5.7 AI assistant review boils down to this: it is a good conversational tool that is genuinely useful for learning, explanation, code generation, and diagnosis. It is not an editor automation tool, and it was not designed to be one.

MCP-based solutions like the Unreal MCP Server are editor automation tools. They execute operations, handle batch processing, and bridge multiple applications. They were designed for production workflows, not conversation.

The Unreal AI assistant vs MCP debate is a false dichotomy. Use both. Use the assistant when you need to understand something. Use MCP when you need to do something. Use UnrealCopilot when you are writing code. Use Ludus AI when you are designing mechanics.

The developers who ship games fastest in 2026 will not be the ones who pick the "best" AI tool. They will be the ones who build an AI toolchain that matches their specific workflow — using each tool for what it does best and not trying to force any single tool to do everything.

Your AI workflow should ship games, not just answer questions about them. Choose accordingly.