Cursor /orchestrate 深度拆解：递归生成Agent，才是AI驾驭大项目的正确姿势

你有没有经历过这种绝望时刻——

把一个大项目扔给AI，让它帮你重构某个模块，结果它改了三个文件之后开始迷路，要么反复问你"接下来该怚么"，要么直接乱改一通，最后留下一堆需要你手动收拾的烂摊子？

你开始怀疑是不是模型不够强，或者是自己Prompt写得不好。于是你开始手动拆任务：先让它改这个文件，再让它改那个，一步一步盯着它走。

结果你发现，你花在"指挥AI"上的时间，比自己直接写还多。

Cursor 的 /orchestrate 命令，正是为了解决这个问题而生的。但大多数人用它的方式，还停留在"换了个命令名"的层面，并没有真正理解它背后的设计逻辑。这篇文章，我们来把这件事讲透。

---

手动拆子任务 vs 递归生成Agent：本质差异在哪？

先用一个类比建立直觉。

你有一个需求：给整个项目补充单元测试。你把它拆成：先测 auth 模块，再测 api 模块，再测 utils……你逐条下指令，每条指令执行完，你来验收，再下下一条。AI是执行者，你是调度者。

这种模式有一个根本缺陷：任务边界的发现权在你手上。你预判不到的复杂度，AI就处理不了。如果 auth 模块里有一个依赖 utils 的边缘情况，你没想到要测，它就不会测。

你只需要说"给这个项目补充单元测试，覆盖率要达到80%"。/orchestrate 会先让一个"规划Agent"分析整个项目结构，发现所有需要测试的模块和它们之间的依赖关系，然后动态生成若干个"执行Agent"，每个Agent负责一个子任务，最后由一个"汇总Agent"整合结果、检查覆盖率、处理冲突。

这个过程中，你从来没有告诉它要分哪几步。它自己发现了任务边界，自己决定了分工。

手动拆任务（人工调度）：

你 → 任务A → AI执行
你 → 任务B → AI执行
你 → 任务C → AI执行
你 → 整合结果

/orchestrate（系统调度）：

你 → "完成目标X"
↓
规划Agent（分析项目）
├── 子Agent-1（auth模块测试）
│   ├── 子Agent-1a（单元测试）
│   └── 子Agent-1b（边界case）
├── 子Agent-2（api模块测试）
└── 子Agent-3（utils模块测试）
↓
汇总Agent（整合 + 验证）

这一字之差的本质是：任务边界的发现权，从人转移到了系统。

这意味着什么？意味着AI能处理你预判不到的复杂度。一个你没想到的模块依赖，一个隐藏在深层的边缘情况，在手动拆任务模式下会被遗漏，在/orchestrate模式下可能被子Agent自动发现并处理。

小结：手动拆任务是你在替AI思考，/orchestrate是让AI自己学会思考。前者的上限是你的认知边界，后者的上限是任务本身的复杂度。

---

递归的"深度"控制：为什么它不会无限套娃？

听到"递归生成Agent"，很多人第一反应是：这不会失控吗？一个Agent生成两个，两个各自再生成两个，最后变成指数爆炸？

这个担心合理，但Cursor的设计里有三层刹车机制。

第一层：任务粒度阈值

每个子Agent在生成下一层子任务之前，会先评估当前任务的粒度。伪代码逻辑大致是这样：

def should_decompose(task):
# 如果任务可以在单次上下文窗口内完成
if estimated_tokens(task) < SINGLE_CONTEXT_THRESHOLD:
return False  # 不再分解，直接执行

# 如果任务的子任务数量会超过最大并发限制
if estimated_subtasks(task) > MAX_CONCURRENT_AGENTS:
return False  # 合并处理，不再递归

return True  # 继续分解

简单说：当一个任务小到"一个Agent一次能搞定"的时候，它就不再往下分解了。这是最基础的收敛条件。

第二层：上下文窗口边界

每个Agent的上下文窗口是有限的。当一个Agent发现把所有子任务的上下文都塞进来会超出窗口限制时，它会选择"横向扩展"（多个并行Agent）而不是"纵向深挖"（继续递归）。这天然限制了递归深度。

第三层：Agent间通信协议

子Agent之间通过结构化的消息协议通信，而不是自由文本。这意味着任务的分解和汇总是有格式约束的，不会出现"Agent A给Agent B传了一堆模糊指令，Agent B又传给Agent C"这种信息熵爆炸的情况。

用一个真实任务来走一遍流程：

输入："给整个项目加单元测试"

第一层（规划Agent）：
扫描项目结构，发现3个核心模块
评估每个模块的测试复杂度
决定：auth模块复杂，需要继续分解；utils模块简单，直接执行

第二层（auth模块Agent）：
发现auth有login、logout、token刷新三个子功能
评估：每个子功能都小于单次上下文阈值
决定：不再分解，直接生成测试代码

执行层：
auth-login Agent：写测试 → 完成
auth-logout Agent：写测试 → 完成
auth-token Agent：写测试 → 完成
utils Agent：写测试 → 完成

汇总层：
整合所有测试文件
运行覆盖率检查
发现覆盖率78%，低于目标
自动识别未覆盖的边缘case，补充测试
最终覆盖率82%，任务完成

整个过程，递归最深只到第二层，因为第三层已经满足"单次上下文可完成"的终止条件。

小结：递归不会失控，因为系统在每一层都在问"还需要继续分解吗"，三层刹车机制确保了收敛。你唯一需要做的，是在最开始给出清晰的目标和约束条件。

---

对普通开发者的实际影响：你的Prompt该怎么变？

理解了原理，接下来是最关键的一跳：你的Prompt粒度应该上移。

不要描述步骤，要描述意图和约束条件。听起来简单，但实际操作中大多数人还是本能地写步骤。下面是三组真实对比：

案例一：给项目加单元测试

❌ 旧写法（步骤导向）：

1. 先看一下src/auth目录下有哪些文件
2. 给auth.js写单元测试，测试login和logout函数
3. 然后看api目录，给api.js写测试
4. 最后整合所有测试文件

✅ 新写法（意图导向）：

/orchestrate 给这个项目的核心业务逻辑补充单元测试。
目标：覆盖率达到80%以上
约束：使用Jest框架，不要修改现有业务代码，测试文件放在对应模块的__tests__目录下

差异在哪？旧写法你预定了步骤，如果你漏掉了某个模块，AI不会帮你找回来。新写法你给了目标和约束，AI会自己扫描项目结构，发现你没想到的模块。

案例二：重构一个复杂模块

❌ 旧写法：

把UserService.js里的getUserById函数改成async/await
然后把updateUser函数也改掉
再把deleteUser改掉
记得处理错误

✅ 新写法：

/orchestrate 将UserService.js从Promise链式调用重构为async/await风格。
目标：所有异步操作统一使用async/await，错误处理使用try/catch
约束：保持现有的函数签名不变，不要破坏调用方的接口
验收条件：重构后所有现有测试仍然通过

旧写法里你手动列举了三个函数，但如果文件里还有第四个你没注意到的异步函数呢？新写法让AI自己去发现所有需要重构的地方。

案例三：代码审查和安全检查

❌ 旧写法：

检查一下有没有SQL注入风险
再看看有没有XSS漏洞
检查一下密码是不是明文存储的

✅ 新写法：

/orchestrate 对这个项目做一次安全审计。
范围：所有涉及用户输入处理、数据库操作、认证授权的代码
输出：按严重程度（高/中/低）分类的安全问题清单，每个问题附上具体的代码位置和修复建议

旧写法你只检查了你想到的三类风险。新写法让AI用专业的安全审计视角去扫描，可能发现你根本没想到的问题类型。

---

💡 想直接测试这些Prompt写法？

如果你想验证"意图导向"和"步骤导向"的Prompt在实际输出上的差距，可以通过 [api.884819.xyz](https://api.884819.xyz) 直接调用 Claude Opus 4.6 或 GPT-5.1 跑对比实验——支持主流模型，注册即送体验 token，国产模型（Deepseek / 千问）完全免费，没有月租，按量付费，适合做这类横向对比测试。

---

这个设计意味着什么？

我不想用"AI要取代程序员"这种话来收尾，因为这既不准确，也没什么帮助。

但有一件事是真实的：会写高层意图Prompt的人，和只会写步骤Prompt的人，能驾驭的项目规模将出现数量级差距。

前者把AI当成一个能自主规划、自主分工、自主收敛的系统来用；后者把AI当成一个需要手把手指挥的执行者。前者的瓶颈是任务本身的复杂度，后者的瓶颈是自己的认知带宽。

从今天开始，试着把你下一个AI任务的Prompt改写成意图导向的形式。不要列步骤，只给目标、约束和验收条件。看看AI能不能自己找到你没想到的路径。

如果它找到了，你会意识到：你以前一直在替AI思考，而它其实早就可以自己想了。

---

下一篇预告：当你有了 /orchestrate 这样的调度层，你的 System Prompt 该怎么写才能真正"管住"这些子Agent？这是大多数教程