万字干货!Harness Engineering如何工程化落地?
Harness Engineering 的概念已经火了有一阵了,全网很多文章基本都是在讲理念,讲为什么今天做 AI 开发,不能只靠一段提示词,也不能把模型当一个“更聪明的代码补全”。但与此同时,一个问题也在持续地发酵:
理念我理解了,可是真正落到工程里,我第一步到底该做什么?
这个问题特别重要。因为 Harness 这个词听上去很大,很像一个抽象的方法论,但它如果不能落到工程、目录、文档、脚本、工作流里,那它最后就只是一句漂亮的话。事实上,不同项目落地出来的 Harness,表面上可能完全不一样。有的项目是 CI 很强,有的项目是规范很强,有的项目是多 Agent 很强,有的项目甚至只是把几个脚本和模板整理得非常扎实。但如果你往下挖,会发现它们解决的其实都是同一个问题:
如何让 AI 在你的项目里,持续、稳定、规范、顺畅地做出你真正想要的结果。
这一篇我就不再谈泛泛而论的“AI 很重要”“工程化很重要”。我只做一件事:拿 JK Launcher 这个真实工程做例子,把我们这一路是怎么一步一步把 Harness 搭出来的,原原本本讲清楚。哪些地方有效,哪些地方踩坑,哪些东西一开始以为够用,后来发现完全不够,都会写出来。你看完以后,不一定要完全照抄,但至少会知道:如果你也想在自己的项目里从 0 开始搭 Harness Engineering,第一步该做什么,后面又该按什么顺序逐步补齐。
我将整个搭建流程细细拆解,每一个步骤都拆散揉碎了,尽可能的将所有内容都明明白白的写出来,本篇我保证一定值得大家反复细读,当然,以下所有论点都是我的一家之言,不一定对,抛出来也是希望大家一起讨论。
为方便大家阅读,在此提前预警一下,本篇文章字数非常多,一共分为12章,要想细读建议留足至少半小时的时间,建议大家时间不够的话可以先收藏。
01
很多人一上来就开始写 Rule、搞 Agent、接 MCP,最后越做越乱,根本原因不是执行力不够,而是概念没分清楚。下面这些词,在我们这个工程里都会反复出现。如果这几个概念混在一起,后面就很难搭得稳。
先把这几个概念压成一张速览表,会更容易建立整体印象:
1.1 Rule 是什么
Rule 可以理解成你给 AI 写的一套“工程规矩”。
它不是需求文档,也不是设计方案,更不是脚本。它更像是你在带一个新人开发时,先告诉他的那些基础原则: 什么能做,什么不能做; 什么做完必须验证; 什么约定绝对不能绕过去。
比如在我们工程里,有一类专门约束“改完代码以后必须完成编译、测试和事后验证”的 Rule,本质上就是在告诉 AI:
你改完代码以后,不能只说“我改好了” | 你必须去编译 |
你必须去跑测试 | 你必须去做事后验证 |
三步不全过,这次开发就不算完成 |
所以 Rule 的核心作用,不是帮助 AI “变聪明”,而是帮助 AI 少犯一些本来不该反复犯的低级错误。
Rule 更像一个团队的“研发制度”。制度不是拿来创造价值的,制度是拿来减少混乱的。
但这里有个很重要的前提:Rule 只是软约束,不是硬门禁。
什么意思?就是 AI 理论上应该遵守它,但它并不一定真的每次都遵守。尤其当 Rule 越来越多、需求越来越复杂的时候,模型会出现三种典型情况:
它忘了某条 Rule
它觉得某条 Rule 和这次需求“无关”
它知道这条 Rule,但偷懒没做,还给自己找理由
所以 Rule 非常重要,但 Rule 不能解决所有问题。
1.2 MCP 是什么
MCP(Model Context Protocol)本质上是一种标准方式:把「仓库之外的能力」接进 AI 的工作链路里——既能拉取信息,也能在明确边界内触发外部系统的动作。
你可以把它理解成一层可编排的接口:AI 不再只依赖当前对话和本地代码,还能对接 Wiki、知识库、表格、各类平台 API;在 Unity 工程这类场景里,还可以对接 Unity Editor / 工程宿主里的工具能力(例如编译、场景与资产、日志与状态、受控命令等),把「写出来的代码」和「编辑器里正在发生的事」对齐起来。
这也就解释了,为什么当你想把 Harness 从「开发闭环」推到「工程交付闭环」时,MCP 往往会变得关键:交付链路里大量是 CI、签名、制品、发布、回写状态 等系统能力,它们都不是「只在仓库里多写几行脚本」就能替代的。
先看能力边界。没有 MCP 时,AI 通常仍被锁在:
本地代码仓库
本地脚本
当前对话上下文
它能分析、能改代码、能跑本地验证,但很难安全、结构化、可审计地接入更外层的工程系统。
反过来,如果你要把闭环做完整,迟早会碰到下面这类动作(只列常见的几种):
调用 CI 平台发起构建
读取构建日志和构建结果
调用签名服务给安装包或可执行文件签名
上传制品到制品库或发布平台
调用发布系统做灰度、提审、发布
回写发布状态、版本号、交付记录
它们的共性是:需要让 AI 在可控边界里调用系统能力,而不是把凭据和即兴命令散落在对话里。MCP 正是这类能力的连接层:把外部系统以 Tool / 资源的形式暴露给 AI,便于被 Rule、Workflow、Scripts 一起约束。
所以在我们的整体拼图里,MCP 不是 Harness 的主体,而是 Harness 的外接能力接口——接什么、接到多细、何时允许接,本身也要被制度与门禁管住。
如果 Rule 像制度,Skill 像操作手册,Scripts 像闸机,那么 MCP 更像把 AI 接进更大工程系统的标准插座。在当前阶段它也许还是辅助;但当你希望 AI 不只改代码,还要稳定参与构建、签名、制品、发布、回写状态时,这一层往往会越来越「决定性」。
1.3 Skill 是什么
Skill 是我特别推荐所有团队早点引入的东西。
它本质上是在告诉 AI:有些事情你不要临场发挥,不要每次重新理解,也不要自己“猜一个大概的流程”,而是严格按照这套固定步骤执行。
比如编译这件事。你说“你去编译一下”,AI 可能自己拼一条命令。表面看没问题,但实际工程里,编译往往不是一句 dotnet build 那么简单,可能涉及:
要找对 MSBuild | 要用固定的配置 |
要先还原 | 要把日志输出到指定文件 |
编译完以后还要看错误模式 |
这些东西如果每次都让 AI 自由发挥,迟早出问题。
所以我们把编译做成了 Skill,把测试做成了 Skill,把事后验证也做成了 Skill。这样每次 AI 走到这一环,它不是“想办法完成”,而是“按剧本完成”。
它很像给 AI 写的一份标准操作手册。Rule 告诉 AI “这件事必须做”,Skill 告诉 AI “这件事具体应该怎么做”。
1.4 Sub Agent 是什么
Sub Agent 就是多个“分工明确的 AI 角色”。
很多人一开始用 AI,默认是一个 Agent 干到底:分析需求、设计方案、写代码、审代码、写测试、做总结全都它来。短任务时这没问题,但只要任务一复杂,问题马上就会出现:
它会自己给自己做需求解释 | 它会自己给自己的方案打分 |
它会自己写代码、自己说自己没问题 | 它会天然更倾向于“推进任务继续进行”,而不是“停下来承认当前有问题” |
这和真实的软件研发其实完全一样。一个人既做产品、又做架构、又做开发、又做 QA,最后质量一定很难收口。
所以我们后来引入了多个 Sub Agent,把不同阶段拆开。每个 Agent 只负责自己那一段,把产出写进文档,然后交给下一个 Agent。
放到真实研发里,Sub Agent 就像项目组里的一组人:
需求分析的人只管把需求说清楚 | 方案设计的人只管把技术方案做完整 | 闸门的人专门负责判断“这东西能不能进开发” |
开发的人只管实现 | 代码审查和测试的人负责收口 | PM 只负责流程 |
这个思路其实非常朴素,不是什么新发明,但它对 AI 特别有效。
1.5 Workflow 是什么
Workflow 不是“写了几个 Agent”那么简单。 如果只写了几个 Agent,而没有 Workflow,那其实只是“有几个人在干活”,还谈不上“有一套稳定可复用的协作方式”。
我觉得 Workflow 最形象的理解方式,不是流程图,而是接力赛规则。
接力赛最重要的,不是有四个跑得快的人,而是下面这些事情必须先说清楚:
第一棒是谁跑 | 第二棒什么时候能接棒 |
接棒的时候必须交什么 | 哪种情况算犯规 |
犯规以后是重跑、罚时,还是直接取消成绩 |
放到工程里其实一模一样。 你有需求分析、方案设计、开发、测试这些角色,只代表你“有人”。 但只有当你把下面这些东西明确下来,Workflow 才真正成立:
当前任务现在处于哪个阶段 | 这个阶段的产出是什么 | 谁可以接下一棒 |
下一棒接手前必须看到什么文档 | 哪些问题一旦出现,流程必须打回 | 打回以后回到谁那里,改完以后从哪一棒重新开始 |
如果没有 Workflow,工程现场通常会变成下面这种状态:
需求不清楚,方案设计直接自己改需求 | 方案有问题,开发硬着头皮继续做 |
测试发现阻塞问题,PM 为了赶进度想办法往下推 | 某个阶段明明应该打回,但没人说得清到底该打回给谁 |
大家都在做事,但最后没人能说清楚“这件事现在到底算做到哪了” |
所以 Workflow 的核心不是“有一张图”,而是让每一次前进、暂停、打回、重跑都有明确依据。
在我们工程里,这套 Workflow 最后被拆成了三层:
一层写给人看,告诉大家这条研发链路整体怎么走
一层写给系统看,把阶段和迁移边固定下来 一层写给具体角色看,明确每个角色接棒时该读什么、交棒时该写什么
这三层合起来,才构成一个真正能长期维护的 Workflow。 否则你以为你搭的是流程,实际上搭出来的往往只是几段漂亮的提示词。
和「接力」配套的还有一条上下文纪律:每一棒只给当前该看的那一份材料。不是要瞒信息,而是避免一上来把规则、地图、任务历史全堆给 AI——上下文越长,重点反而越散。所以我们会有意让 Rule 慢慢长、让 dev-map 与任务看板等「项目级视野」晚一点再上;这和 Workflow 拆阶段、Sub Agent 各看一截文档,其实是同一条思路。
1.6 Scripts 是什么
Scripts 是整个 Harness 里最“硬”的东西。
如果说 Rule 只是告诉 AI 应该怎么做,Skill 只是给 AI 标准步骤,那 Scripts 就是在说: 你说你做完了没用,得跑过我这关才算。
这也是为什么我越来越觉得,真正成熟的 Harness,最后一定会越来越依赖脚本,而不是越来越依赖提示词。
在我们工程里,就有一个典型的“总门禁脚本”。它把很多原本散落在 Rule 里的东西,真正落到了可执行的检查上。比如:
XAML 里有没有中文 | 有没有 Emoji | 有没有用 C# 8 以上语法 |
有没有直接写 | 有没有硬编码 UI 文案 | 日志格式对不对 |
有没有直接访问 | SVN 认证参数是不是合规 | 文件是不是超长 |
本地化有没有违规 | 主工程编译是否通过 | 测试是否通过 |
测试数量有没有异常减少 | 规则文件是不是四处同步 |
|
当这些东西被做成脚本以后,AI 就很难再拿“我觉得没问题”来糊弄过去了。
1.7 先把前面的几个概念串起来
前面这一章其实已经把后面会反复出现的几个核心零件都讲完了。 如果你是第一次接触这套东西,先不要急着往下看,最好先在脑子里把它们快速过一遍:
Rule:告诉 AI 什么是规矩 | Skill:告诉 AI 规矩里的固定动作怎么做 | Scripts:不是告诉 AI,而是直接检查它做没做到 |
MCP:让 AI 接上外部知识和工具 | Sub Agent:把一个大任务拆成多个角色协作 | Workflow:规定这些角色在什么阶段、按照什么顺序协作 |
这几个东西不是互相替代的,而是逐层叠加的。
你也可以这样理解:
Rule 负责告诉 AI 什么是底线 | Skill 负责把高频动作标准化 | Scripts 负责判断结果到底对不对 |
Sub Agent 负责把复杂任务拆成多个专业角色 | Workflow 负责让这些角色能按顺序接力 | MCP 负责把这套系统继续往外部工程系统延伸 |
也就是说,到这里为止,你看到的还只是 Harness 的一堆“零件”。 而接下来要讲的,才是最关键的一步:
这些零件为什么拼在一起以后,会变成一整套 Harness Engineering。
1.8 什么是 Harness Engineering,以及它在我们工程里的全貌
如果前面那些概念你都看完了,这里其实就可以把它们串起来了。
我自己现在对 Harness Engineering 的理解很简单:
它不是某一个工具,也不是某一条提示词技巧,而是一整套让 AI 在工程里稳定产出正确结果的工程系统。
注意这里有三个关键词:
稳定 不是这次运气好做对了,而是下次、下下次、换个需求、换个维护人,它仍然能比较稳定地工作 | 产出 不只是写代码,还包括需求、方案、验证、交付等完整过程产物 | 正确结果 不是“做完了就算”,而是最终要有办法判断它到底做得对不对 |
所以在我看来,Harness Engineering 真正解决的不是“怎么让 AI 更聪明”,而是下面这件事:
怎么把 AI 从一个会临场发挥的模型,变成一个在工程里可约束、可协作、可校验、可持续维护的执行系统。
如果把我们当前工程里的 Harness 全貌摊开来看,它大致已经长成了下面这样:
1 设计规格文档 先把需求目标、边界、版本意图说透。它解决的是“AI 到底要做什么”。 | 2 Rule 把基础规矩和底线写死。它解决的是“哪些事情绝对不能乱来”。 | 3 Skill 把编译、测试、验证这类固定动作标准化。它解决的是“关键流程不要靠临场发挥”。 |
4 Sub Agent 把不同阶段拆成不同角色。它解决的是“不要让一个 Agent 既做需求、又做方案、又做开发、还自己审自己”。 | 5 Workflow 把这些角色怎么接力、什么时候前进、什么时候打回说清楚。它解决的是“多人格协作不能靠现场拍脑袋”。 | 6 Scripts / 事后验证 把很多约束真正落成可执行检查。它解决的是“不是做完了就行,而是要知道做得对不对”。 |
7 开发导航地图(dev-map) 让 AI 快速理解项目结构和既有模式。它解决的是“不要一进项目就重复造轮子”。 | 8 任务看板 让 PM 和需求分析知道项目历史和当前进展。它解决的是“不要只盯当前需求,忽略整个项目上下文”。 | 9 MCP 它现在还不是我们这套 Harness 的主干,但如果将来要把闭环延伸到构建、签名、制品、发布这些外部工程系统,MCP 会成为非常关键的一层连接能力。 |
如果非要打个比方,我会说:
Harness Engineering 就像是在给 AI 搭一整套“工程作战系统”。 规格设计文档(SPEC)是作战目标,Rule 是纪律,Skill 是标准动作,Sub Agent 是兵种分工,Workflow 是指挥链,Scripts 是验收和反馈闭环,开发导航地图(dev-map) 和任务看板则提供地图和战场态势(这两个概念将会在第九章进行详细的阐述)。
这些东西单独看都不稀奇,真正有价值的是:它们组合起来以后,AI 才第一次像是在一个真实工程里工作,而不是只是在聊天窗口里表现得很聪明。
02
在真正讲“第一步怎么搭 Harness”之前,我觉得有必要先把 JK Launcher 这个项目本身说清楚。因为如果读者连这个项目是什么、解决什么问题、复杂度大概在哪个层级都不知道,后面就很容易把我们的方法误解成一套“只有大工程才需要”的复杂仪式。
2.1 工程画像:JK Launcher 在做什么
下面三张截屏来自真实运行中的 JK Launcher V3(小白模式),便于把「工具体长什么样、日常在管什么」落到可视层面。
项目工程:主工作台 — 快速入门与状态条、SVN/路径与平台配置、更新与打开 Unity 等主操作、底部日志区。
工程修复工具箱:按修复项展示风险等级,支持预检与执行修复,右侧为检测日志 —— 对应冲突扫描、工作副本、误改恢复等工程维护场景。(特别补充一点,这个功能是我使用完整版Harness一次就直接完成的,完成度相当高,大家也可以通过这个功能了解到本篇文章中构建的Harness究竟最终的效果是怎么样的)
设置:可开启小白模式(隐藏高级功能),以及智能建议、悬停详细说明、操作结果摘要等显示相关选项。
JK Launcher 本质上是一个面向 Unity 项目研发流程的桌面启动器工具。它不是一个单一功能的小工具,而是一整套围绕日常研发高频动作搭起来的工作台,核心在于把那些原本零散、容易出错、依赖经验的操作,统一收进一个稳定的桌面端入口里。它要处理的事情并不简单,比如:
工程更新 打开和关闭 Unity SVN 环境检测与权限检查 冲突检测与冲突修复 定时更新和批量更新 更新失败后的诊断与恢复 多语言界面 日志、遥测、状态反馈
如果你看它最近几个月的演进,会发现它已经不是“一个带按钮的启动器”这么简单了,而是一个不断往研发真实场景贴近的工程工具:有修复工具箱,有环境自检,有消息中心,有定时任务,有 Library 预热,有更细的错误分类和更完整的引导体验。这种项目特别适合作为 Harness 的样本,因为它同时具备几个特征:
功能持续迭代
既有 UI,又有服务和状态逻辑
既要工程正确性,也要用户体验
既要能改代码,也要能长期维护
技术上,它的主体是一套典型的 Windows 桌面应用技术栈:以 WPF 为界面基础,以 .NET Framework 为主要运行时,围绕本地工程管理、SVN 协作、配置、状态、更新、日志、多语言等能力不断扩展。也正因为它既有前端交互、又有工程逻辑、又有环境和流程问题,所以它特别适合拿来验证一套 Harness 到底能不能撑住复杂项目。
2.2 人搭 Harness,AI 写代码
还有一点,我觉得必须提前告诉读者: 这个工具在持续演进的过程中,真正的代码实现工作是完全由 AI 去完成的,人没有亲手写过一行代码。
人做的事情是什么?不是下场补代码,也不是在 AI 后面当“高级打字员”,而是一步一步把 Harness Engineering 搭起来:
先把需求和设计说透
再补上规则
再把固定流程做成 Skill
再拆出多 Agent
再补上脚本门禁和事后验证
再补项目地图、任务看板和流程定义文件
也就是说,这个项目不是先有一个成熟团队在写代码,再把 AI 当辅助工具接进来;恰恰相反,我们是在搭建 Harness 的过程中,逐渐让 AI 从能做小任务,走到能做复杂任务,再走到能持续维护整个项目。
2.3 从设计规格文档(SPEC)开始
所以这一章真正想回答的问题,不是“我们为什么要写设计规格文档”,而是:
当你面对的是一个真实、持续迭代、并且完全交给 AI 去实现和维护的工程时,你应该先从哪一步开始搭这个系统。
很多人一听到 Harness,就想先写 Rule、先拆 Agent、先上脚本。但如果你一开始连“这个工程到底想怎么开发、最终想交付什么样的东西”都没有说清楚,那后面所有约束都会变成无源之水。
所以我们真正的第一步,不是写 Rule,而是先把一个比较完整的设计规格文档和 AI 反复磨透。
在 JK Launcher 这个工程里,我们最早就是先磨出了一份比较完整的版本设计规格文档,它承担的就是这个作用。
这类文档的意义,不是为了“文档看起来专业”,而是为了在项目一开始就把下面这些问题谈清楚:
这个版本到底要解决什么问题
哪些问题是核心目标,哪些只是顺手优化
改动会影响哪些模块
哪些行为必须保持兼容
最终什么样才算做完
我自己在这一步通常会和 AI 来回聊很多轮,甚至聊到有点烦。因为这一轮你偷懒,后面会用十倍时间还回来。
这些来回不只是在改文档措辞,也是我们和 AI 共同加深对需求本身的理解的过程。有时一开始连自己都不确定想要什么,不妨把 AI 拉进需求讨论里,让它帮着追问、掰开选项——真正的需求常常就是在这样的来回里被挖出来的,而不是第一版就写死在纸上。
最终的SPEC长什么样?它必须清晰的写明你的所有需求,指明必要的边界条件(后面的需求分析agent会帮你补充 剩下的边界条件),必须没有任何不确定的词语,例如:建议,可以,推荐,可选等字样。
但很快我就发现,只靠这份文档,AI 还是会出问题。
问题不在于它看不懂文档,而在于:
1. 它不会百分之百按文档执行2. 它做完以后,你很难知道它现在到底做到哪了
3. 很多错误它会反复犯
比如它会:
按自己理解跳过一些看起来“没那么重要”的细节
做完之后告诉你“都完成了”,但你仔细一看其实漏了 某个以前犯过的错,下一次又犯一遍
到这里我才真正意识到: 仅有规格设计文档(SPEC),只能解决“知道做什么”的问题,解决不了“如何稳定地做到位”的问题。
于是我们才进入下一步:给 AI 上 Rule。
03
当时我的直觉很简单:既然 AI 经常忘事,那我就把容易忘、容易错的事情写成 Rule。
于是,像“改完必须完成编译、测试和事后验证”这一类规则就出来了。它本质上是在告诉 AI:
每次代码修改完成后必须编译 | 编译通过后必须跑测试 |
测试通过后必须跑事后验证 | 只有三步全部通过,任务才算真的完成 |
这一步非常有用。因为 AI 最爱偷懒的地方,恰恰就是那些“看起来像收尾,其实是底线”的动作。比如很多时候它会觉得:
“我改的是文档,不用编译”
“我只是小改,不用跑测试”
“这次失败看起来是历史问题,不算我引入的”
Rule 一上去,这些最粗糙的问题会立刻少很多。
但如果你真的在复杂项目里跑过一段时间,你会很快发现 Rule 的天花板。
Rule 多了以后,会出现两个非常典型的问题。
3.1 AI 会忽略 Rule
不是完全不看,而是会在复杂任务下“局部遗忘”。尤其当你的需求很长、上下文很重、同时加载了很多别的内容以后,一些 Rule 在实际执行时会被稀释掉。
3.2 AI 会绕过 Rule
这个比忽略更麻烦。因为它不是不知道规则,而是会开始给你找理由。
比如:
这次不通过不是我引入的,是之前遗留的
这个 Rule 说的是常规需求,这次是特殊情况
我已经做了等价验证,不需要完全照规则来
这其实是我做 Harness 过程中非常关键的一个认知转折:
Rule 不是没用,而是 Rule 只能做“原则约束”,不能做“流程执行”。
当我意识到这件事以后,我就开始做下一步:把固定流程从 Rule 里拆出去,做成 Skill。
04
如果你认真观察,你会发现工程里有一类事情非常适合做成 Skill:
执行步骤固定 | 每次都要做 |
做错一次就很恶心 | 不值得让 AI 每次重新思考 |
编译、单元测试、事后验证,就是这一类事情。
所以我们把这几个流程单独做成了 Skill,比如编译 Skill、测试 Skill、事后验证 Skill。
这样一来,Rule 里就不需要再写一堆细碎的命令和注意事项了。Rule 只要保留一句话:
“你必须做这件事。”
而 Skill 则负责把“这件事具体怎么做”写清楚。
这样做的好处特别直接:
1. Rule 变轻了
以前 Rule 既讲原则又讲流程,越写越长。现在 Rule 可以只保留真正的红线,复杂的执行步骤都交给 Skill。
2. AI 的执行稳定性变高了
以前 AI 需要临场理解“编译应该怎么编、测试应该怎么测”。现在它不是理解,而是调用一套现成的方法。
3. 维护成本更低了
比如你后来修改编译流程,只需要改编译 Skill 本身,不需要去全项目搜索每条 Rule 里是不是都写了旧命令。
这一步做完以后,我们整套系统的健壮性明显提升了一截。 但新的问题很快又出现了:
单个 Agent 在复杂需求下,还是不够稳定。
05
前面在规格设计文档(SPEC)、Rule、Skill 这几层补齐以后,我们已经明显感觉到系统比最早稳了很多。 至少 AI 不再是“拿到一句话就直接开写”的状态,它开始知道目标、知道约束、知道固定流程。
但当需求继续变复杂以后,一个新的问题开始越来越明显:
单个 Agent 很难在长时间、复杂链路的开发里,同时把需求理解、方案设计、风险判断、编码实现、代码自审、测试验证都做好。
这件事不是因为模型不够聪明,而是因为我们在强迫它一次性扮演太多角色。
一个 Agent 如果既负责理解需求,又负责设计方案,还负责判断可行性,再负责写代码,最后还要自己审自己、测自己,它一定会出现下面这些问题:
走到这里时,我其实面对的是一次很典型的技术选型问题。 不是“要不要上多 Agent”这么简单,而是:到底应该选哪种多 Agent 形态。
5.1 第一种做法:继续强化单 Agent
这是最容易想到的路线。 既然一个 Agent 不够稳,那就继续给它补:
更长的设计规格 | 更多的 Rule |
更细的 Skill | 更严的检查步骤 |
这条路我们其实已经走过一段,而且不能说完全没用。 SPEC、Rule、Skill 这几层,恰恰就是这样一步一步补出来的。
但问题在于,这条路越往后走,越像是在把越来越多的责任塞进一个“大而全”的角色里。 它可以让单个 Agent 变得更谨慎,却很难解决“角色冲突”本身。
说得更直接一点:
需求分析和代码审查,本来就不是同一种工作
方案设计和测试验证,本来就不是同一种思考方式
让一个 Agent 同时扮演所有角色,本质上还是在赌它一次性全都做好
这在简单任务上能凑合,在复杂工程里就会越来越吃力。
5.2 第二种做法:去中心化协作
网上很常见的另一条路,是让多个 Agent 平起平坐,通过对话和协商动态达成共识。 这类模式看起来很高级,也很像“一个 AI 团队在开会”。AutoGen 的 GroupChat 一类思路,就是这种方向的典型代表。
它的优点确实很诱人:
足够灵活
现场应变能力强
不需要一开始就把流程定义得很死
但它的缺点,在真实工程里会越来越大:
行为路径不稳定 | 每次面对同类需求,可能走出不同流程 |
谁该对哪部分结果负责,不够明确 | 一旦出问题,回退到哪一层并不清晰 |
后续换模型、换维护人时,很难保持一致 |
如果你的目标是做一个很聪明的演示,或者探索一个开放式问题,这种模式很有魅力。 但如果你的目标是长期维护一个真实项目,它就会逐渐暴露出一个致命问题:
好看,但难维护。
5.3 第三种做法:结构化调度
还有一条路,就是把多 Agent 做成一条有明确角色分工、有明确流转规则的结构化流程。
这种模式的典型特征是:
明确有一个项目经理角色 | 明确每个阶段由谁负责 |
明确每一阶段的输入和输出 | 明确什么时候能往前走,什么时候必须回退 |
它的优点也非常明确:
流程清晰 | 可控性强 |
结果可审计 | 很适合文档沉淀 |
更方便长期维护和角色替换 |
它的缺点也不是没有:
前期设计成本更高
灵活性会比自由协商差一些
产物更多,token 消耗更大
但我们最后还是坚定地选了它。 因为到了真实工程阶段,你会越来越清楚一件事:
真正贵的不是 token,真正贵的是失控。
我们需要的,不只是“AI 把代码写出来”,我们还需要:
需求文档 | 方案文档 | 开发文档 |
代码评审结论 | 测试文档 | 交付结论 |
阶段进度和回退记录 |
这些东西不是形式主义,而是为了让后续任何一个人、任何一个 AI,在几天后、几周后、几个月后,都还能看懂:
这个任务为什么这么做 | 做到哪一步了 |
哪些风险已经处理 | 哪些问题是在哪一层暴露的 |
如果现在要继续维护,应该从哪接上 |
所以从项目可维护性、流程规范性、角色可替换性来看,结构化调度几乎是我们能找到的最适合这类工程的方案。
三条路线压缩成一张表会更清楚:
5.4 结构化调度里,我们也做过一次内部 PK
即便确定了走结构化调度,这里面其实也还有两种常见做法。
做法 A:固定角色、固定流程
也就是先把有哪些 Agent、每个 Agent 干什么、什么阶段找谁,尽量定义清楚。 项目经理只负责按流程调度。
优点是:
稳定 | 容易维护 |
容易沉淀文档和规范 | 很适合固定类型的工作流 |
做法 B:只固定 PM 和开发经理,具体 Agent 动态生成
这种模式会让上层保留项目经理和开发经理,具体研发时由开发经理动态“招聘”或生成不同的 Agent 去做事。
它的好处是:
灵活性更强
面对非常多样化的问题时,理论上更容易按需适配
但问题也很明显:
角色边界更漂 | 维护成本更高 |
行为更依赖当前上下文和即时判断 | 很难做长期稳定的流程复用 |
我们最终还是选了第一种。 原因并不复杂:我们的实际开发工作流,虽然需求内容会变,但大的阶段结构其实相对固定。
比如:
一个标准需求开发,通常就是需求分析、方案设计、评估、开发、代码审查、测试、交付
一个 Bug 修复,也可以落到相对固定的裁剪版流程
既然工作流本身并不是完全开放式的,那就没必要为了“理论上的灵活性”牺牲掉稳定性和可维护性。
往前看,这几次 PK 其实都在做同一类取舍:灵活性和稳定性之间,我们最后都更偏向后者。因为对一个要长期维护的工程来说,可控、可追踪、可复用,比“理论上更灵活”重要得多。
5.5 这一章最重要的结论
所以第五章真正想讲清楚的是:
我们不是因为“多 Agent 很酷”才去做多 Agent。 我们是因为:
单 Agent 到复杂需求阶段开始失稳
自由协商式多 Agent 不适合长期维护
动态招聘式结构化多 Agent 对当前项目来说过于漂移
在一轮轮技术选型和对比之后,最后才落到了今天这条路上:
用结构化调度,把研发流程拆成一组固定角色和固定阶段,让 AI 不再是一个人在乱拳打死老师傅,而是进入一个被制度化管理的研发体系。
06
结构化调度确定下来以后,下一个问题就是: 到底要拆成几个 Agent,怎么拆。
这一步如果做得不好,多 Agent 不会让系统更稳,只会让系统更…