AI 使用建议：写给 Unity 程序员（2026 版）

适用对象：正在用或准备用 AI 辅助 Unity / C# 开发的客户端程序员。
定位：不吹「AI 替代人」，也不神化工具——只讲怎么把 AI 用在刀刃上、又不让它变成负债。
核心结论：AI 是倍乘器，不是替代；human-in-the-loop（人在回路）仍是行业最被认可的形态。

0. 一句话总览

对 Unity 程序员来说，2026 年 AI 的正确打开方式不是「让它写整个功能」，而是：

用规范契约把项目框住 → 在受控范围内让 AI 生成高频重复代码 → 编译门禁 + 人 review 兜底 → 把输出和上下文落盘复用。

你负责「定边界和拍板」，AI 负责「在边界内填代码」。再把这套思路接到 Unity 本身，就有了「AI 操作 Editor」的桥。

一、先认清：AI 在你的工作里是什么角色

角色定位	适合干的事	不适合干的事
倍乘器（提效）	样板代码、数据协议、UI 绑定、命名重构、查文档	架构决策、跨模块隐式耦合改动
结对（建议）	给方案、找 bug、解释报错、写测试	不熟悉的引擎版本 / 插件 API
替代（危险）	——	无监督改 20 个文件、动渲染管线、性能兜底

行业共识：自主 Agent 只适合边界清晰、可验证的任务；无监督大范围改代码是负债。 你走「人在回路」是对的方向。

二、工具怎么选（2026 现状）

工具	定位	用法建议
Cursor	主力编码助手，已流行近 2 年	日常 AI 辅助开发主场，适合长期沉淀项目上下文
Claude Code / Codex	终端 Agent，能跑命令、改多文件	适合「给清楚任务 → 它执行 → 你 review」的闭环
Unity 官方 AI（6.x）	AI Assistant / Generators / Inference Engine + MCP Server	Agent 可读场景、GameObject、组件、Console，触发编辑器操作；官方 plugin 支持 Claude Code / Codex / Grok
Bezi	浏览器 3D 协作 + Unity Editor 内 AI 结对（Sidekick）	学它的「上下文索引 + 人在回路 + 编辑器沉淀」思路；但别把它的 MCP 当通用 MCP 深度来吹
国内模型（豆包 / 通义 / 混元等）	中文语境、合规、本地化	用于中文文档生成、注释、需求拆解，注意数据出境与订阅门槛

经验：工具用得多 ≠ 理解得深。 会用 MCP，不等于会搭桥——transport、schema、鉴权这些底层细节，才决定你到底走多深。

三、★ 落地闭环：六段式（最该照做的骨架）

规范契约层 + 受控执行面 + 外部化上下文仓 + 读前约定 + 编译门禁 + 人在回路

环节	人话	怎么做
规范契约层 (md)	把项目约定写进文档	`ARCHITECTURE.md` / `CONVENTIONS.md`：命名、分层、可用 API、目录结构
受控执行面 (Slot)	只给 AI 一个清晰的「插槽」	不让它漫游全工程，限定「输入什么、产出什么形状」
外部化上下文仓 (cont)	中间产物落盘	生成结果 / 摘要写进文件或索引，不堆在聊天窗口
读前约定 (Spec-First)	动手前先读规范 + 现状	每次任务先读 md + 对应 cont，再生成，防幻觉
编译门禁 (Compile Gate)	生成的不盲信	编译 / 静态检查 / 单测过才保留，不过就丢
人在回路 (HITL Diff)	你 review 才落地	AI 给 diff，你确认才进工程

三个最容易漏的点

cont 会过期 → 必须 md 为唯一事实源，cont 每次跑前重新索引，否则 cont 本身制造新幻觉。
插槽契约得先清晰 → 缺口不是随便挖，先定义输入输出形状，否则 AI 乱生成比不接 AI 更糟。
编译门禁是最后闸 → 生成完必须编译 / 单测 / 静态检查过才写回 cont。

四、Unity 里最适合让 AI 干的 6 件事

数据协议 / 配置类代码：Cfg 表、ScriptableObject 字段、序列化类——模式固定，AI 按表生成最稳。
UI / 交互绑定样板：UGUI 的 View / Model 绑定、按钮事件、多语言 key 注入——重复度高，吃模板。
固定模式 class：对象池、状态机、MonoBehaviour 模板、单例 / 服务定位——结构雷同，AI 填最快。
编辑器工具：EditorWindow、AssetPostprocessor、MenuItem、自动化构建脚本——一次性产出，收益长。
查错与解释：把报错 / 堆栈 / 一段陌生代码丢给 AI，让它定位原因或讲解——比翻文档快。
单元测试与编译验证：让 AI 先写测试，再让你本地编译门禁兜底——把「看起来对」变成「跑得过」。

反向清单（别让 AI 碰）：渲染管线 / Renderer Feature 顺序、性能兜底（GC / 合批）、网络同步、跨 20 个文件的隐式耦合改动。这些要么边界模糊，要么错了代价大。

五、防幻觉三板斧（每次都过）

板斧	做法
契约前置	先定接口 / 数据协议 / 类型签名，再让 AI 按契约填，不靠它猜
编译门禁	生成后必须编译 / 静态检查 / 单测过才保留，不过就重写
人在回路	你 diff review 后才落地，AI 不直接合进主干

六、上下文怎么管（别让它越来越笨）

信息前置汇聚：把散落在代码 / 口头约定里的信息集中成 md / 索引，任务前注入，不等它问。
任务原子化：一次只给一个明确任务，避免超长对话漂移。
输出落盘 (cont)：生成结果写进文件 / 索引，不靠聊天窗口记忆，下次直接读。
定期刷新：文档与代码对齐，防止规范过期产生新幻觉。

七、常见反模式与治理（挑真实踩过的讲）

反模式 ① 脚本耦合爆炸：AI 一改牵一片。
治理：契约前置、分层边界、依赖单向、事件总线解耦、模板化生成。

反模式 ② 上下文丢失：AI 越聊越偏、忘了约定。
治理：信息前置汇聚、cont 落盘、读前约定、任务原子化、摘要刷新。

反模式 ③ API 幻觉：编造不存在的 Unity API / 字段。
治理：编译门禁、显式类型声明、锁引擎版本、最小可运行样例、自动测试。

八、★ 把 AI 接进 Unity：CLI 与 MCP

光让 AI 写代码还不够，下一步是让 AI 直接操作 Unity Editor。这里的关键是分清两种技术，以及怎么从零搭一个最小桥。

8.1 一句话区别

它们不是替代关系，是不同层。CLI = 可执行程序（实现层）；MCP = 通信协议（接口层）。
一个 MCP Server 内部，经常就是去调用 CLI 或 SDK。底层用 CLI / 桥实现能力，外面套一层 MCP 给 AI 用——两者可以同时成立。

8.2 对比表

维度	CLI	MCP
本质	一个可执行程序 / 脚本	一套通信协议（JSON-RPC）
接口描述	靠 `--help` 或文档，人读了再告诉 AI	自描述：AI 能 `list tools` 拿到 schema
调用方式	进程 + 命令行参数	发 JSON-RPC 请求
状态	通常无状态，跑完就退	可保持会话 / 连接
返回结构	stdout 文本（要自己约定 JSON）	原生结构化返回
谁能用	任何 AI / shell / CI / 人	需要 MCP Client（Cursor / Claude Code 等）
上手成本	低	中
调试	简单，直接跑命令看输出	链路长（AI → client → server → 引擎）
适合	确定性任务、构建、批量处理、CI	AI 自主发现工具、多工具编排、多 Agent

一句话比喻：CLI 是给你一把锤子，怎么用靠说明书；MCP 是一个会自己报菜单的工具箱，AI 一打开就知道有哪些工具、每个要什么参数。

8.3 分层关系（看懂这张就不迷糊）

┌─────────────────────────────────────────────┐
│  AI Client（Cursor / Claude Code / 多 Agent）│
└───────────────┬──────────────┬──────────────┘
                │              │
       ①CLI 路径│              │②MCP 路径
                ▼              ▼
      ┌──────────────┐  ┌──────────────────┐
      │  Bash 工具    │  │  MCP Server       │
      │  执行命令     │  │  (Python/TS)      │
      └──────┬───────┘  └────────┬─────────┘
             │   stdout/JSON      │ 内部通常也是
             │                    │ 调用 CLI/HTTP
             └────────┬───────────┘
                      ▼
        ┌──────────────────────────────┐
        │  Unity 侧                     │
        │  A. Unity.exe -batchmode      │
        │  B. Editor 常驻 HTTP 桥       │
        └──────────────────────────────┘

关键点：MCP 那一路的 Server，底下多半还是走 CLI 或 HTTP 桥。MCP 是外壳，CLI / 桥是内核。

8.4 什么时候用哪个

场景	选 CLI	选 MCP
构建打包、资源导入、跑测试	✅	可
人也要用、CI 也要用	✅	不必要
让 AI 自己发现有哪些能力		✅
多 Agent 编排、工具很多		✅
需要保持 Editor 状态、频繁交互		✅（但底层仍需桥）
一次性确定性任务	✅	过重

实践建议：先 CLI，后 MCP。 先把能力用 CLI 跑通，再包一层 MCP 给 AI 自动发现。

8.5 自建最小 Unity 桥三步走

Step 1：最简 batchmode CLI（10 分钟能跑通）

C# 侧 Assets/Editor/AiBatch.cs：

using UnityEditor;
using UnityEngine;

public static class AiBatch
{
    // Unity.exe -batchmode -quit -executeMethod AiBatch.Exec -aiCmd buildAndroid
    public static void Exec()
    {
        var args = System.Environment.GetCommandLineArgs();
        string cmd = GetArg(args, "-aiCmd") ?? "noop";

        switch (cmd)
        {
            case "buildAndroid":
                var report = BuildPipeline.BuildPlayer(
                    new[] { "Assets/Scenes/Main.unity" },
                    "Builds/android/game.apk",
                    BuildTarget.Android,
                    BuildOptions.None);
                Log($"{{\"ok\":true,\"result\":\"{report.summary.result}\"}}");
                break;

            case "hierarchy":
                var sb = new System.Text.StringBuilder();
                foreach (var go in UnityEngine.SceneManagement.SceneManager
                             .GetActiveScene().GetRootGameObjects())
                    sb.AppendLine(go.name);
                Log($"{{\"ok\":true,\"roots\":\"{Esc(sb.ToString())}\"}}");
                break;

            default:
                Log("{\"ok\":false,\"error\":\"unknown cmd\"}");
                break;
        }
    }

    static string GetArg(string[] a, string key)
    {
        for (int i = 0; i < a.Length - 1; i++)
            if (a[i] == key) return a[i + 1];
        return null;
    }

    static void Log(string json) => Debug.Log("[AI_OUT]" + json);
    static string Esc(string s) => s.Replace("\\", "\\\\").Replace("\"", "\\\"")
                                    .Replace("\n", "\\n");
}

命令行调用：

"C:/Program Files/Unity/Hub/Editor/2022.3.62f1/Editor/Unity.exe" \
  -batchmode -quit \
  -projectPath "D:/MyGame" \
  -executeMethod AiBatch.Exec \
  -aiCmd hierarchy \
  -logFile -

CLI 侧从 stdout 里 grep [AI_OUT] 前缀取 JSON。缺点：每次冷启动 Unity 要 1~3 分钟，只适合构建 / 批处理，不适合交互。

Step 2：常驻 Editor 桥（解决「慢」）

思路：Editor 开着，里面跑一个 HTTP 服务，外部用 curl / 脚本调，毫秒级响应。

C# 侧 Assets/Editor/AiBridgeServer.cs：

using System.Collections.Generic;
using System.Net;
using System.Threading;
using UnityEditor;
using UnityEngine;

[InitializeOnLoad]
public static class AiBridgeServer
{
    const int Port = 8765;
    static HttpListener _listener;
    static readonly Queue<(HttpListenerContext ctx, string body)> _queue = new();
    static readonly object _lock = new();

    static AiBridgeServer()
    {
        Start();
        EditorApplication.update += Pump;   // Unity API 必须回主线程
    }

    static void Start()
    {
        _listener = new HttpListener();
        _listener.Prefixes.Add($"http://127.0.0.1:{Port}/");
        _listener.Start();

        new Thread(() =>
        {
            while (true)
            {
                var ctx = _listener.GetContext();
                var body = new System.IO.StreamReader(ctx.Request.InputStream)
                              .ReadToEnd();
                lock (_lock) _queue.Enqueue((ctx, body));
            }
        }) { IsBackground = true }.Start();
    }

    // 主线程消费队列 → 安全调用 Unity API
    static void Pump()
    {
        while (true)
        {
            (HttpListenerContext ctx, string body) item;
            lock (_lock)
            {
                if (_queue.Count == 0) return;
                item = _queue.Dequeue();
            }

            string resp = Dispatch(item.body);
            var bytes = System.Text.Encoding.UTF8.GetBytes(resp);
            item.ctx.Response.ContentType = "application/json";
            item.ctx.Response.OutputStream.Write(bytes, 0, bytes.Length);
            item.ctx.Response.Close();
        }
    }

    static string Dispatch(string body)
    {
        try
        {
            var req = JsonUtility.FromJson<Req>(body);
            switch (req.cmd)
            {
                case "hierarchy":
                    var sb = new System.Text.StringBuilder();
                    foreach (var go in UnityEngine.SceneManagement.SceneManager
                                 .GetActiveScene().GetRootGameObjects())
                        sb.AppendLine(go.name);
                    return Json($"\"roots\":\"{Esc(sb.ToString())}\"");

                case "create":
                    var obj = new GameObject(string.IsNullOrEmpty(req.name)
                        ? "AIObj" : req.name);
                    Undo.RegisterCreatedObjectUndo(obj, "AI Create");
                    return Json($"\"created\":\"{Esc(obj.name)}\"");

                case "select":
                    var found = GameObject.Find(req.name);
                    Selection.activeGameObject = found;
                    return Json($"\"found\":{(found != null).ToString().ToLower()}");

                case "play":
                    EditorApplication.isPlaying = true;
                    return Json("\"playing\":true");

                default:
                    return "{\"ok\":false,\"error\":\"unknown cmd\"}";
            }
        }
        catch (System.Exception e)
        {
            return "{\"ok\":false,\"error\":\"" + Esc(e.Message) + "\"}";
        }
    }

    static string Json(string body) => "{\"ok\":true," + body + "}";
    static string Esc(string s) => s.Replace("\\", "\\\\").Replace("\"", "\\\"")
                                    .Replace("\n", "\\n");

    [System.Serializable] class Req { public string cmd; public string name; }
}

调用：

curl -s -X POST http://127.0.0.1:8765/exec \
  -H "Content-Type: application/json" \
  -d "{\"cmd\":\"create\",\"name\":\"AIFoo\"}"
# → {"ok":true,"created":"AIFoo"}

这一步就已经是「AI×Unity 桥」了：AI 只要能发 HTTP，就能操作 Unity。

Step 3：套成 MCP（给 AI 自动发现）

Python 侧（pip install mcp requests）：

from mcp.server.fastmcp import FastMCP
import requests

mcp = FastMCP("unity-bridge")
BASE = "http://127.0.0.1:8765"

def _post(payload: dict) -> str:
    r = requests.post(f"{BASE}/exec", json=payload, timeout=60)
    return r.text

@mcp.tool()
def unity_get_hierarchy() -> str:
    """读取 Unity 当前场景的根节点列表"""
    return _post({"cmd": "hierarchy"})

@mcp.tool()
def unity_create_gameobject(name: str) -> str:
    """在 Unity 当前场景创建一个空 GameObject"""
    return _post({"cmd": "create", "name": name})

@mcp.tool()
def unity_select(name: str) -> str:
    """按名字选中场景里的 GameObject"""
    return _post({"cmd": "select", "name": name})

@mcp.tool()
def unity_play() -> str:
    """让 Unity 进入 Play 模式"""
    return _post({"cmd": "play"})

if __name__ == "__main__":
    mcp.run()

Cursor 侧配置 .cursor/mcp.json：

{
  "mcpServers": {
    "unity-bridge": {
      "command": "python",
      "args": ["D:/tools/unity_mcp/server.py"]
    }
  }
}

重启 Cursor → 工具列表里出现 unity_get_hierarchy 等 4 个工具 → AI 自动发现、直接调用，你不用再在 prompt 里写命令。

8.6 使用方式对比（AI 视角）

	CLI 用法	MCP 用法
AI 怎么调	通过 Bash 工具执行命令	直接调 tool
参数从哪来	你写在 md 里的命令清单	自动拿 schema
返回怎么读	自己解析 stdout 的 JSON	结构化对象
出错怎么查	看退出码 + stderr	tool 返回 error
prompt 里要写啥	必须写清命令格式	不用写，AI 自己发现

所以：CLI 时代，md 里必须有一份「命令手册」；MCP 时代，schema 代替了手册，但 md 仍要写「业务约定」（命名、边界、什么时候用哪个工具）。

8.7 坑清单（真做才踩得到）

坑	说明	解
batchmode 慢	每次冷启动 1-3 分钟	改常驻桥
Unity API 非线程安全	HTTP 回调在子线程，直接调 Editor API 会崩	队列 + `EditorApplication.update` 主线程消费
端口冲突	多个 Unity 项目同时开	端口可配 / 按项目分配
无鉴权	本地端口任何进程可调	团队加 token，只绑 127.0.0.1
大输出爆上下文	整棵场景树几千节点	分页 / 只返回根节点 / 截断
编译期卡死	脚本编译时 Editor 主线程阻塞	请求超时 + 重试
版本 API 差异	不同 Unity 版本方法签名不同	锁定版本，`.cs` 里做好兼容
中文乱码	C# 文件编码	`.cs` 存 UTF-8；Windows 脚本别混 GBK

8.8 小结：落地顺序

MCP 是协议层，CLI 是实现层。 桥负责让 AI 能调用 Unity Editor 的能力，外面套一层 MCP 就能让 Cursor 自动发现工具；即便不套 MCP，HTTP 桥 + JSON 也能独立工作。

落地顺序建议：先 batchmode 跑通 → 再常驻桥 → 最后包 MCP。Step 2 就是最小可用的「AI×Unity 桥」，后面加不加 MCP，取决于你是否需要 AI 自动发现工具。

九、行动清单（给 Unity 程序员的）

优先级	动作
P0	给自己项目写一份 `CONVENTIONS.md`（命名 / 分层 / 可用 API），喂给 AI
P0	把高频样板（数据协议、UI 绑定、对象池）做成模板，让 AI 按模板填
P1	接入编译门禁：生成代码本地编译过才合，不过就丢
P1	试点一个编辑器小工具（如自动绑定 / Missing 检查），从最小一处开始接 AI
P2	跑通「batchmode CLI → 常驻 HTTP 桥 → 包 MCP」小闭环，让 AI 能读场景 / 改组件
P2	沉淀 cont：把踩过的坑和生成的复用代码落盘成索引

收尾：AI 不会替你背锅，但能替你搬砖。把重复、模式固定、可验证的活交给它，把架构、性能、拍板留给自己——这就是 2026 年 Unity 程序员最稳的 AI 用法。至于「让 AI 操作 Unity」这件事，记住一句：CLI 是能干活的程序，MCP 是让 AI 知道怎么使唤它的协议；自建的顺序永远是先把活干成 CLI，再包成 MCP。

Wind Dust's Blog

行到水深处，坐看云起时