铃阅
❌

普通视图

腾讯云开发者社区携 WorkBuddy 出海,拓展马来西亚 AI 生态

2026年11月13日 18:43

原创 腾讯云开发者 2026-11-13 18:43 广东

关注腾讯云开发者,一手技术干货提前解锁👇

开发者公众号专属群聊

扫码加入获取更多一手教程、科技前沿报告

2026 年 10 月 10 日,腾讯云开发者社区和 AI Hackerdorm合作举办,BuilderX 社区参与共建的 Tencent Cloud Community Builders 计划首场落地活动——Dormathon 2026 黑客松在马来西亚举行。赛事于 Taylor’s University、Universiti Putra Malaysia(UPM)及 Swinburne University of Technology 砂拉越校区三所高校同步开赛,汇聚马来西亚高校开发者,以项目实践探索 AI 技术的应用可能。这也是 WorkBuddy 出海的第一站。作为赛事的重要实践工具,WorkBuddy 首次走进马来西亚本地校园,连接大学生与开发者,推动 AI 工具从产品认知走向实际应用,让创意在真实场景中转化为项目成果。

对腾讯云开发者社区而言,这场赛事的意义不止于一次黑客松,更是 Tencent Cloud Community Builders 计划从理念走向实践的第一步。以赛事为入口,连接本地高校与开发者;以 WorkBuddy 赛道承载真实开发,鼓励参与者围绕实际需求开展项目探索;再通过优秀作品沉淀可复用的实践案例,并以社区承接赛后的持续交流,逐步建立起从活动参与、工具实践到社区连接的完整路径。

本次活动覆盖马来西亚 20 余所高校,吸引 10,000 余名本地大学生与开发者关注,最终共有 160 余支队伍、500 余名参赛者参与。在这一跨校交流平台上,WorkBuddy 赛道涌现出围绕企业经营、学生创业和校园协作等场景的应用探索,为 WorkBuddy 在马来西亚积累了真实、多元的用户实践案例。腾讯云开发者社区也借此进一步连接本地高校与开发者群体,推动 WorkBuddy 的海外用户生态从校园向更广泛的本地开发者社区延伸。

01

三校联动,连接马来西亚高校开发者

走向海外,不只是让产品被看见,更重要的是走近当地用户,融入他们的学习、创作与问题解决过程。这也是 Tencent Cloud Community Builders 计划选择高校作为海外生态建设首站的重要原因。高校聚集着大量青年开发者,是新技术被尝试、被讨论、被验证的重要场景,也是连接下一代开发者与技术生态的重要入口。

Dormathon 2026 的三校联动,为 WorkBuddy 提供了深入马来西亚校园、连接本地开发者的实践机会。围绕黑客松的真实项目任务,参赛者结合自身需求探索工具的使用方式,并通过作品呈现对 AI 应用的理解。WorkBuddy 与本地用户的连接,也由此从产品认知延伸至实际体验与项目实践,让工具真正融入开发者的创作过程。

从赛事落地到赛道运营,腾讯云开发者社区也在主动探索海外社区建设的有效路径。作为 Tencent Cloud Community Builders 计划的首场落地实践,社区不仅支持赛事举办,更主导 WorkBuddy 专项赛道的设置与运营,并与 BuilderX 社区等伙伴共同完成赛事生态共建,将产品能力、开发工具与项目评审机制融入赛事全流程。同时,通过赛事传播、优秀作品展示与开发者交流,将一次校园黑客松延伸为面向更广泛本地开发者群体的交流与实践平台。

02

用WorkBuddy产出实践,让本地需求成为创作起点

本次赛事不仅让 WorkBuddy 走进马来西亚校园,更通过真实项目实践,沉淀了一批具有本地应用价值的作品。这些成果既呈现了当地开发者的实际需求与应用探索,也为 WorkBuddy 后续的本地化发展提供了实践参考。通过赛事连接校园、以作品沉淀实践、以社区延续交流,Tencent Cloud Community Builders 正推动 WorkBuddy 从走进海外市场,逐步融入本地开发者生态。

在 WorkBuddy 赛道,参赛者围绕身边的真实需求展开探索:中小企业如何高效整理月末账务,经营小生意的学生如何清晰掌握收益,大学社团如何更有条理地筹备活动。三个获奖项目从不同角度展现了 AI 工具在本地生活与工作场景中的应用潜力,也让 WorkBuddy 的海外实践有了更加具体的成果。

第一名|Alt F4:为中小企业整理可复核的月末账务

Swinburne 赛区 · 项目:TutupBuku

面对银行流水、收据和账目之间繁杂的核对工作,Alt F4 团队开发了 TutupBuku。项目以一句指令为起点,组织检查、校验、匹配和复核流程,最终输出一套可追溯到源文件的月末账务审查包。

它没有把目标设定为替企业自动完成结账,而是帮助使用者整理证据、发现差异,并将无法确认的问题交由人工处理。金额计算与账目匹配由程序完成,AI 负责规划与分析,确保建议和计算结果之间有明确分工。

这一作品将 AI 应用探索带入中小企业的日常经营场景,也为 WorkBuddy 用户提供了一个具体参考:从重复、零散的信息处理任务切入,逐步构建能够辅助实际工作的应用。

第二名|Stuff:帮助学生看清小生意的真实收入

Swinburne 赛区 · 项目:Lembur

Stuff 团队关注的是经营小生意的学生。摆摊、接单、代购带来了收入,但采购支出、零散成本和投入时间往往难以完整记录,也让“自己每小时到底赚了多少”成为一个不容易回答的问题。

团队开发的 Lembur 将使用入口放在 Telegram 中,通过收据照片、订单截图等材料,组织记账、对账和收入分析,并尝试生成经营调整建议。使用者可以修正系统推断的工时,对外发布或供应商沟通等动作则需要经过批准。

这一设计从学生熟悉的沟通方式出发,把 AI 应用融入日常经营流程。它也说明,本地开发者对生活场景的理解,能够为 WorkBuddy 用户实践带来更贴近实际的创作方向。

第三名|Moomin Valley:让大学社团活动更有条理

Taylor’s 赛区 · 项目:Movents

Moomin Valley 团队将视角转向校园社团,开发了活动管理应用 Movents。围绕一次活动的筹备,项目尝试将时间线、预算、提案、场地、人员分工与审批等环节组织在同一套流程中。

通过 MCP 接口,支持该协议的 AI 助手可以在授权范围内调用活动管理工具,辅助准备材料、更新任务和检查安排;需要更高权限的操作则进入审批流程。活动结束后的复盘,也可以沉淀为下一次策划的参考。

从校园需求出发,再以作品回应校园协作问题,Movents 呈现了青年开发者参与 AI 创作的一条路径。这样的实践,也让 WorkBuddy 与高校用户的连接有了赛事之外的延伸空间。

三个项目共同构成了此次 WorkBuddy 马来西亚站的用户实践样本。从企业账务到学生经营,再到社团协作,本地开发者正在结合自身经验探索应用,让 WorkBuddy 的海外实践拥有更丰富的场景与内容。

03

从一次赛事,走向持续的本地社区共建

赛事落幕,但创意与实践可以继续延伸。Dormathon 2026 积累的项目成果与技术经验,不仅展现了马来西亚高校开发者对 AI 应用的探索,也为 WorkBuddy 在当地积累了更多真实的用户实践案例。

从校园赛事到日常技术交流,腾讯云开发者社区希望进一步延续这份连接,并期待与 BuilderX 社区等伙伴一起,把这座连接国内与全球开发者的桥搭得更宽。

Tencent Cloud Community Builders(腾讯云开发者社区共建者) 是腾讯云开发者社区面向全球 AI 爱好者推出的官方社群计划。计划通过活动举办、实践项目、知识分享及内容创作,支持成员将创意转化为实际行动,在技术交流与协作中拓展个人影响力,共同推动全球 AI 生态发展。

成为 Builder,你可以组织活动、开发项目、分享知识,并获得腾讯云资源代金券、官方曝光、活动支持及合作机会,让创意落地,推动项目持续成长。

我们期待更多全球开发者及 AI 爱好者加入 Tencent Cloud Community Builders,无论是分享 WorkBuddy 使用经验、开发 AI 应用、创作技术内容,还是组织校园交流活动,都可以成为社区共建的一部分。

从三校联动到项目实践,再到社区连接,Dormathon 2026 为 WorkBuddy 在马来西亚的生态拓展迈出了新的一步。未来,腾讯云开发者社区将继续连接本地高校、开发者与技术社群,让更多创意落地、项目成长,让赛事中的创新成果延伸至更广泛的社区实践。

-End-

感谢你读到这里,不如关注一下?👇

扫码领取腾讯云开发者专属服务器代金券!

图片

跳转微信打开

维护3.3万字符的长Prompt?让优化Agent迭代执行Agent

2026年11月12日 09:09

原创 徐泓镔 2026-11-12 09:09 广东

关注腾讯云开发者,一手技术干货提前解锁👇

开发者公众号专属群聊

扫码加入获取更多一手教程、科技前沿报告

手工调 Prompt 是个重复、费人、又难以持续的活。这篇文章记录我们如何借助 Google Research 开源的 harness²(Recursive Agent Harnessing)框架,让一个"优化 agent"自动迭代负责打标的"执行 agent",并针对有人工标注、可量化准召的连贯性打标任务做了适配。在 611 条数据上跑 1 轮(约 95 分钟,无人工介入),问题类 F1 从 82.78% 提升到 89.89%。

01

背景

本章要点:本次优化对象是一份超过三万字符、由历史规则逐步累积而成的 Prompt。此前,我们已基于 Skill 构建自我迭代闭环;流程虽然能够完整运行,但连续迭代 5 个版本后,准确率和召回率仍未显著提升。其核心问题在于改进过程缺乏清晰的组织方式。

 1.1 任务背景:连贯性打标

在输入法联想场景中,系统根据用户输入的上文生成若干联想候选。我们使用一个 LLM 节点,依据一份长 Prompt(超过三万字符,由历史规则逐步累积而成),逐一评估每个候选的连贯性,再与人工标注进行对比,以候选为单位统计准确率和召回率。问题识别是本任务的核心目标:问题样本占比约 6%,但会直接影响用户体验,因此需要重点关注其识别准确率、召回率和 F1。

本实践包含两类 agent,二者职责如下:

  • 执行 agent:使用固定模型和当前 Prompt 完成候选打标,是被优化的对象。

  • 优化 agent:读取执行 agent 的指标与失分样本,分析原因并改写 Prompt,负责推动迭代。

图 1 执行 agent 与优化 agent 的自动迭代闭环

本实践的核心是让优化 agent 自主完成“发现问题—修改 Prompt—执行验证”的闭环,减少人工在各个环节之间的传递与协调。

 1.2 此前实践:基于 Skill 构建自我迭代闭环

在引入 harness² 之前,我们已基于 Skill 构建一套完整的自我迭代闭环:由 agent 读取打标结果和人工标注,分析失分样本并改写 Prompt,随后重新执行评测。该流程能够完整运行,但实际效果有限:连续迭代 5 个版本后,准确率和召回率仍未显著提升。

复盘发现,瓶颈不在于能否形成闭环,而在于闭环内的改进过程缺乏有效组织。此前的 Skill 仅为 agent 提供“提升准确率和召回率”这一笼统目标。同一 agent 需要同时处理输出格式不稳定、规则优先级冲突、特定判例缺少规则等性质不同的问题。由于缺乏明确的改动边界,各版本往往同时调整多个方面,因而难以定位收益与回退的具体来源。

下一章介绍的 harness²,为组织这一改进过程提供了更体系化的方法。

02

过程与方法

 2.1 方法与工具:harness²,让 agent 迭代自己的"外壳"

节要点:harness² [2]将改进拆分为 INV(怎么工作)和 DOM(需要知道什么)两个视角,并行生成提案,再依据执行证据进行合并,同时将经验沉淀到可选择性复用的经验库中。k=1 时,一轮流程包括 base、提案、探测与合成。

 2.1.1 背景

LLM agent 的表现不仅取决于底层模型,也受到其外部运行配置 harness 的影响,包括系统提示词、记忆、技能、工具说明、脚本和子 agent 编排等,可概括为 Agent = Model + Harness。同一模型采用不同的 harness 时,表现可能存在明显差异。harness² 将 harness 拆分为 8 个可编辑组件,每个组件在运行时对应一个文件:

图 2 harness² 的 8 个可编辑组件(图源:论文 [1] Figure 2)

手工调整 harness 需要持续投入工程精力,为降低这一成本,出现了“让 AI 自主改进 harness”的思路,即递归自我改进(RSI)。早期方法(如 Meta-Harness [4] )在一批训练任务上离线搜索最优 harness,并在部署后保持固定。然而,真实场景中的任务持续出现且通常包含未见任务,同时往往缺乏标准答案。论文 [1] 指出的两个难点正在于此:

  1. 任务缺乏真值或可靠的验证器,难以可靠判断修改后的 harness 是否优于原版本;

  2. 针对单个任务形成的改进,难以自动沉淀并迁移到后续任务。

harness² 通过两层递归回应上述问题:任务级递归用于改进当前任务的 harness,harness 级递归用于沉淀和复用改进经验。

 2.1.2 运行机制

图 3 harness² 整体流程(图源:论文 [1] Figure 3;左侧为任务级递归,右侧为 harness 级递归)

任务级递归:Propose、Probe、Compose 三步。

  1. base 执行。 使用当前 harness 执行一次任务,获得“参考执行”。该结果仅用于描述当前 harness 的行为,并不代表其输出正确。

  2. Propose(提案)。 两个编辑器基于参考执行,分别生成 INV 和 DOM 两版候选 harness,且两路无法查看彼此的改动。

  3. Probe(探测)。 每个候选 harness 在相同的模型和环境下重新执行,并与参考执行进行对比,形成“行为对比”:目标问题是否缓解、行为是否保持不变,以及是否出现回退。需要强调的是,这些对比仅作为后续决策的证据,并不等同于正确性验证。

  4. Compose(合成)。 合成 agent 读取参考执行、两个候选、它们相对当前版本的 diff 以及全部执行证据,有选择地合并有证据支持的改动、修订相互冲突的改动、仅采纳其中一路,或保持原样。每项决策均需对应具体的执行观察,而非仅基于“预期指标提升”的假设。合成后的 harness 再执行一次,得到本轮最终结果。

INV 与 DOM 的分工是该方法的关键设计:

两路分别聚焦“工作方式”与“领域知识”,再由合成阶段整合双方收益。与单一 agent 同时处理两类问题相比,这种分工更加聚焦,也能减少改动之间的相互干扰(论文的消融结果见 2.1.3)。

此外,预算参数 k 用于控制探索宽度(图 4):并行模式为 INV/DOM 候选增加 k 个独立合成会话,并最终选择一个结果;串行模式则将 k 个对比步骤依次衔接,后一步基于前一步继续修改。k=1 时两种模式等价,均对应上述基本流程。本文实践均采用 k=1。

图 4 并行与串行递归(图源:论文 [1] Figure 4)

harness 级递归:经验沉淀。 任务结束后,反思 agent 会复盘完整的改进记录,包括参考执行、候选、行为对比、合成决策与最终结果,并提炼各项改动解决的缺陷、适用条件及实际影响。只有获得行为对比支撑的经验才会保留。这些经验连同被采纳的 harness 一起写入改进经验库(每条包含一个可执行的 harness 和一份 EXPERIENCE.md,另附索引)。下一个任务仍从同一个初始 harness 出发,但在提案和合成阶段可以按需读取经验库并有选择地复用,而非自动继承。这体现了“递归”的第二层含义:改进对象不仅是执行 harness,改进机制本身也会随着经验积累持续完善。

 2.1.3 适用场景

harness² 适用于以下场景:模型保持固定且不进行微调,能力主要由 Prompt、脚本和技能等外部配置决定;任务可以自动执行并留下可对比的轨迹与产物;任务持续出现,且缺乏现成的验证器或验证器成本较高。软件开发、办公文档与法律文书等通用 agent 任务,是论文验证的典型对象。

论文在 3 个专业基准和 4 种执行配置上进行了验证。仅执行一步对比改进(k=1)即可稳定提升指标,最高在 WorkBuddy-Bench 上提升 11.5 分、JobBench 上提升 4.5 分、LAB 上提升 11.8 个百分点;随着预算增加,指标进一步改善。消融实验也表明三项设计各有贡献:移除 INV/DOM 分路后,WorkBuddy-Bench / JobBench 分别下降 2.9 / 3.7 分;移除合成后,分别下降 1.6 / 1.9 分;移除经验库后,分别下降 3.1 / 1.8 分。

需要说明的是,论文以“没有真值”为基本设定,而本任务具有人工标注和可量化的准确率、召回率。这一差异决定了后续的适配取舍(见 2.2.3)。

 2.1.4 与此前 Skill 实践的区别

针对 1.2 节所述问题,harness² 与此前的 Skill 实践主要有以下两点差异:

1. 体系化的 Propose、Probe、Compose,尤其是 Propose 阶段的视角拆分。 harness² 将改进过程拆分为两个视角,而非由单一 agent 负责全部修改:INV 仅关注 workflow(agent 如何工作,包括输出格式、规则冲突与流程),DOM 仅关注领域知识(如何判定,包括规则、例外与判例)。两路彼此独立,无法查看对方的改动;每路改动先单独执行一次(Probe),留下可对比的证据;最后由 Compose 依据这些证据进行合并。这种“分视角提案、依证据合并”的方式,使每路改动更加聚焦、可追溯,并减少两类改动之间的相互干扰。

相比之下,此前的 Skill 仅以准确率和召回率为整体目标,缺乏上述分工。这是其连续迭代 5 个版本仍未显著提升,而 harness² 单轮即取得明显改善的关键差异(两路的具体收益见第三章)。

2. 可沉淀、可选择性复用的经验。 每轮结束后,harness² 会复盘全部改动,将有执行证据支撑的经验和被采纳的 harness 存入经验库;后续任务可以按需读取、有选择地复用,而非自动继承上一版。这种机制使改进方法能够随任务积累持续完善,避免每轮从零开始。此前的 Skill 未包含这一机制,各轮改进彼此孤立。

在本任务中,两层 harness 分别对应:执行 harness 为当前 Prompt 及可选脚本;改进 harness 为优化 agent 使用的任务说明与经验库。前者在每轮迭代中被修改,后者随经验积累持续完善。

 2.2 适配:将 harness² 应用于具有真值的打标任务

节要点:harness² 面向通用 agent 任务,而本任务在 harness 抽象与存量 Prompt 的映射、执行环节形态以及真值可用性三个方面,均与其默认设定存在差异。基于其开源实现 [3],我们在不修改框架本体的前提下增加约 2400 行适配层,仅在运行时覆盖与“无真值”相关的通用声明。其中,真值可用性的适配是核心。

 2.2.1 难点一:将 harness 抽象映射到具体任务,调整通用约束以适配存量 Prompt

问题: harness² 将 harness 拆分为 8 个可编辑组件,而本任务执行侧实际生效的仅有 Prompt 和少量脚本,对 skills、子 agent 或插件的修改不会影响执行结果。与此同时,优化对象是一份超过三万字符、由历史规则累积而成的存量 Prompt,框架的默认约束并不完全适用:

  • 可编辑范围过宽,导致优化 agent 可能生成不会影响执行结果的文件改动;

  • 框架对每次加载的常驻内容(系统提示词等)设置了 24000 字符上限,以避免内容无限膨胀;然而,本任务的 Prompt 本身就是执行 agent 的系统提示词,初始长度约为 3.3 万字符,已经超过该上限;

  • 面对长 Prompt,优化 agent 可能出于结构性整理的目的进行大幅精简或重写,导致用于修复历史问题的规则失效。

方案: 根据存量 Prompt 的特点,逐项调整通用框架约束:

  • 限定并校验可编辑范围。仅允许修改 Prompt 本体和少量配套文件。若候选包含其他文件改动,校验环节将拒绝该候选,并将原因反馈给优化 agent 重试;

  • 放宽常驻内容上限。将上限由 24000 调整至 50000 字符,为新增规则保留空间,并在优化 agent 的任务说明中注明当前 Prompt 长度;

  • 约束优化方式。将以下要求写入任务说明:采用小步修改,每轮仅处理失分最集中的若干类别;不得出于“整洁”目的大幅精简;规则冲突时应明确优先级和适用例外,而非直接删除其中一条;不得改变模型输出结构,以确保下游能够正常解析结果。

 2.2.2 难点二:执行 agent 的形态不同,需要重写执行环节

问题:harness² 中的“执行”是启动一个 agent 在沙箱中完成长任务,并收集其轨迹与产物;本任务的“执行”则是对评测集中的 611 条数据逐条进行单轮打标,再计算评测指标。

方案:不沿用原框架的执行 agent,而是整体重写该环节:

  • 执行流程重写。将 harness 中实际生效的文件组合为 system prompt,并发调用模型完成全量数据打标,再沿用原有打标 workflow 完成结果解析、diff 与评测。最终产出指标和逐条预测,以替代 agent 轨迹;

  • 并发与保护。为同一模型设置全局并发上限,以约束 INV 和 DOM 两路并行探测的总负载;正式执行前先使用少量数据进行冒烟测试,若出现大面积失败则立即中止,避免继续执行后续优化。

 2.2.3 难点三(核心):通用 agent 任务与可量化评估任务存在本质差异

问题: harness² 默认任务没有真值,agent 会收到“没有评分标准、没有标准答案”的明确说明,只能通过对比 base 与候选的行为差异评估改动,最终由无法访问真值的 selector 进行选择。本任务则具有人工标注,可以直接计算准确率、召回率和 F1,因而能够为优化提供明确方向。

图 5 harness² 默认设定与连贯性打标任务的对照

真值提供了比默认设定更明确的反馈信号,但必须将其完整、准确地传递给优化 agent,否则优化仍只能依赖模型直觉。

方案: 围绕真值的使用,从以下四个方面进行改造:

① 将真值与评测指标纳入执行证据。每轮执行后,harness² 会向优化 agent 提供一份“轨迹”,我们将其改造成两部分:

  • 汇总指标:问题识别的准确率、召回率、F1,以及因输出格式问题被丢弃的记录数;

  • 分歧样本:逐条列出模型与人工标注不一致的样本,并区分漏判(降低召回率)、误判(降低准确率)和输出格式异常。每条样本包含上下文、人工标注、模型标注及模型生成的判断依据,优化 agent 据此分析模型的误判原因。

② 为优化 agent 编写专用任务说明。框架允许为优化 agent 附加项目说明,主要包含以下三类内容:

  • 评测口径:明确准确率和召回率的计算方法,以及判定优化有效的标准;

  • 工作方法:先汇总失分点并按原因聚类,再结合模型判断依据分析根因,最后在 Prompt 中定位并修改对应规则;

  • 约束与节奏:遵循 2.2.1 节所述改动原则,并及时开展文件修改,避免长时间停留在推理阶段。此前测试中曾出现 agent 因长时间只推理、不修改文件而被上游中断,导致本轮改动被框架丢弃。

需要特别注意的是,输出格式异常的记录会被整条丢弃且不参与评分,因此输出格式稳定性会直接影响评测结果。我们在任务说明中明确这一点,使优化 agent 将格式问题纳入优化目标(第三章中 inv1 的部分收益即来源于此)。

③ 基于指标进行选择与采纳。官方 selector 无法访问真值,只能依据规则和源材料进行推断。由于人工标注口径与模型直觉可能存在分歧,仅依赖上述间接信息进行选择并不可靠。因此,我们改为按问题识别 F1 在 base、inv1、dom1、agg1 四个版本中选择最优版本,仅当其相对 base 的提升超过设定阈值时才采纳,否则保留原 Prompt。

版本命名中,base 表示未优化的基线;inv 和 dom 分别对应 INV(怎么工作)与 DOM(需要知道什么)两条优化路径;agg 是 aggregate 的缩写,表示两路改动的合成;末尾数字表示迭代轮次。因此,inv1、dom1 和 agg1 分别指第 1 轮的 INV 候选、DOM 候选和合成版本。

④ 防止优化 agent 过拟合评测集。 由于优化 agent 可以访问人工标注,直接将评测样本原文写入 Prompt 可能形成表面上的指标提升。为避免这一问题,我们在候选 Prompt 执行前增加校验:保护起始 Prompt 中已有示例,不允许删改;新增示例不得与评测集样本完全一致。未通过校验的候选将被拒绝,并反馈原因供优化 agent 重试。

 2.2.4 适配后的 harness² 如何运转

图 6 适配后的 harness² 单轮流程:双路并行提案、全量验证、合成择优与经验沉淀

单轮(k=1)流程如下:

  1. base 执行。 使用当前 Prompt 对全量数据执行一次打标,完成评测并整理执行证据。

  2. INV、DOM 两路并行优化。 两个优化 agent 读取同一份证据,且无法查看彼此的改动,分别改写 Prompt。INV 路径侧重输出格式稳定性、规则冲突与优先级、措辞与位置;DOM 路径侧重针对集中出现的错误类别补充规则与例外,并修正表述不准确的规则。

  3. 校验与探测。 两个候选分别通过校验后,各自在全量数据上重新执行,获得 inv1 和 dom1 的评测指标。

  4. 合成。 合成 agent 对比 base、inv1、dom1 的 diff 与指标,择优合并并生成 agg1,随后进行全量执行。若两路改动涉及同一规则且存在冲突,合成 agent 将按既定裁决顺序重写。

  5. 选择与采纳。按问题识别 F1 在四个版本中选择最优版本,仅当其相对 base 的提升超过阈值时才采纳。

  6. 经验沉淀。反思 agent 复盘整轮改动,将有执行证据支撑的经验写入经验库。

每轮需要 4 次全量执行(base、inv1、dom1、agg1,共约 2400 次打标调用)和 4 次优化 agent 调用(INV、DOM、合成、经验反思),单次优化调用约 10—20 分钟。轮次结束后,系统自动生成结果报告,包含各版本的完整指标和 Prompt 改动清单。若需在已采纳版本上继续迭代,可通过 --continue 启动下一轮:系统将上次采纳版本作为新基线,递增轮次编号,并保留历史结果与经验库。

03

成效

本章要点:在包含 611 条数据的评测集上完成 1 轮迭代后,问题识别 F1 由 82.78% 提升至 89.89%。四个版本的结果体现了 INV 与 DOM 的分工:INV 主要改善召回率,DOM 主要改善准确率,合成版本则整合两路收益。

 3.1 整体结果

本次实验在包含 611 条数据的评测集上完成了 1 轮迭代,整轮耗时约 95 分钟。执行 agent 采用 DeepSeek V4 Pro 模型 [5],实验过程中的模型调用均通过 CodeBuddy [6] 完成。最终评测结果如下图所示:

图 7 611 条评测数据的问题识别指标对比

最终版本 agg1 实现了准确率、召回率和 F1 的同步提升。 相比 base,问题识别准确率由 78.84% 提升至 87.43%,提高 8.59 个百分点;召回率由 87.13% 提升至 92.49%,提高 5.36 个百分点;F1 由 82.78% 提升至 89.89%,提高 7.11 个百分点。这表明合成版本既减少了误判,也进一步降低了漏判,综合效果优于任一单路优化版本。

 3.2 INV 与 DOM 各自的贡献

  • inv1(仅调整“怎么做”):召回率由 87.13% 提升至 90.17%。 优化 agent 在 base 的失分样本中发现了一类典型的“工作方式”问题:Prompt 正文明确禁止使用代码块围栏,但其内置输出样例却包含围栏。由于模型倾向于模仿样例,原本合法的 JSON 因包含围栏而无法解析,导致整条记录被丢弃。inv1 将输出样例修改为裸 JSON,并在样例处重申该约束;同时新增“输出前核对段数”的要求,以减少候选并段、漏段造成的数量不一致。修改后,无输出记录由 6 条降至 0 条,数量不符记录由 6 条降至 1 条,因格式问题被丢弃的记录减少,召回率随之提升。

  • dom1(仅调整“判什么”):准确率由 78.84% 提升至 89.24%。 DOM 针对失分较集中的误判类别补充了判例、规则和例外,模型判为问题但被人工标注否定的样本由 base 的 40 个降至 17 个。然而,该路径未处理格式问题,代码块围栏问题反而加重:无输出记录增至 28 条,另有 9 条数量不符,共 37 条记录被丢弃。由于有效评分样本减少,准确率提升中包含一定的虚高成分;召回率仅小幅提升至 88.68%。

  • agg1(合成版本):F1 最高,准确率为 87.43%,召回率为 92.49%。 合成 agent 以 base 为基础,保留 inv1 的全部改动,并整合 dom1 的领域规则。两路改动在同一规则上存在冲突:inv1 已定义“冲突裁决顺序”,合成阶段据此重写 dom1 补丁中与旧规则冲突的两处表述。最终,inv1 的格式修复得以保留,dom1 带来的准确率收益也基本保留(87.43%),召回率则高于任一单路版本;无输出记录为 0 条,数量不符仅 1 条。同时,整体一致性由 97.71% 提升至 98.60%,正常类 F1 由 98.78% 提升至 99.25%,表明问题识别能力的提升未以损害其他类别为代价。

这些结果与论文的消融结论一致:INV 与 DOM 分别改善不同维度,任一路径均无法独立达到最终效果,只有经过合成才能整合两路收益。

04

经验总结

本章要点:Skill 闭环与 harness² 的效果差异,主要来自改进过程的组织方式、评估信号的使用和经验的沉淀,与模型本身无关。我们据此总结出 5 条经验,适用于各类 Prompt / workflow 优化,也适用于在新场景中引入 harness²。

回顾整个过程:此前基于 Skill 的自我迭代闭环连续迭代 5 个版本,准确率和召回率仍未显著提升;引入 harness² 后,仅一轮迭代问题识别 F1 就提升了 7.11 个百分点。两者的差别不在模型本身,而在于改进过程如何组织、评估信号如何使用、经验如何沉淀。通过这次实践,我们得出了以下经验。它们不局限于连贯性打标,也适用于其他基于 Prompt / workflow 的 LLM 任务优化,以及在新场景中引入 harness² 的过程。

  • 改进需要有组织,仅形成闭环还不够。 如果由同一个 agent 同时处理格式、规则冲突、领域判例等性质不同的问题,各项改动没有边界,就无法判断收益来自哪里。本次单轮见效的关键在于三步:按“怎么工作”和“需要知道什么”拆开提案,两路分别验证,再依据证据合并。两路的收益分别体现在召回率和准确率上,经过合成后才叠加起来。

  • 引入框架时借鉴方法,不照搬形态。 不修改框架本体,在外层完成适配:把抽象组件映射到实际生效的文件,并限定可改动的范围;按自身任务的形态重写执行环节;逐项检查默认约束是否适用。面对存量长 Prompt,尤其要禁止出于整洁目的的大幅重写,避免历史上修复问题时加入的规则失效。

  • 有可靠的评估信号,就要把它完整交给优化 agent。 信号不仅包括汇总指标,还包括附带模型判断依据的分歧样本,后者是定位根因的主要依据。评分口径中的隐含规则(例如格式异常的记录整条丢弃)也要写明。最终由指标加阈值决定是否采纳,并通过机械校验拦截对评测集的过拟合。

  • 评估结果时不能只看主指标。 dom1 的准确率最高,但因格式问题丢弃了 37 条记录,部分收益属于虚高。每个版本都应同时核对有效样本数和其他类别的指标。

  • 经验库只沉淀有证据支撑、可以迁移的经验。 本轮写入经验库的一条经验是:Prompt 正文禁止某种输出格式,内置样例却使用了这种格式时,模型会模仿样例,导致输出无法解析。这条经验适用于所有需要结构化输出的 LLM 节点。后续任务应按需检索、有选择地复用经验,而不是自动继承上一版配置。

 参考资料

[1] Ruiyao Xu, Yanfei Chen, Zhongying CuiZhu, Bhavana Dalvi Mishra, Yifei Ming, Han Yu, Rujun Han, Chen-Yu Lee, Tomas Pfister. Harness 2: Recursive Agent Harnessing for an Open World. arXiv:2610.14224, 2026.

[2] harness² 项目主页:https://harness2.github.io

[3] harness² 开源代码:https://github.com/google-research/harness2

[4] Yoonho Lee, Roshen S. Nair, Qizheng Zhang, Kangwook Lee, Omar Khattab, Chelsea Finn. Meta-Harness: End-to-end optimization of model harnesses. COLM 2026. https://openreview.net/forum?id=tmbOUyFx3R

[5] DeepSeek-AI. DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence. arXiv:2606.19348, 2026. https://arxiv.org/abs/2606.19348

[6] CodeBuddy CLI 官方文档:https://www.codebuddy.cn/cli/

-End-

原创作者|徐泓镔

感谢你读到这里,不如关注一下?👇

扫码领取腾讯云开发者专属服务器代金券!

图片

跳转微信打开

AI 10分钟写完代码,你2小时还在验?用验收Agent补上最后一公里

2026年11月11日 08:45

原创 吴思 2026-11-11 08:45 中国澳门

关注腾讯云开发者,一手技术干货提前解锁👇

开发者公众号专属群聊

扫码加入获取更多一手教程、科技前沿报告

当 AI 大幅提升代码生成效率后,一个新的问题也慢慢浮现:代码写得更快了,却更难判断它是否真的能用。光靠静态 Review 很难确认 AI 生成的代码是否满足需求。于是,我们在代码生成之后再向后多做一步:让 AI 真实调用接口,并结合接口返回、业务状态、日志、DB 等信息,逐层验证代码是否真正实现了需求。本文将介绍如何通过真实执行和多层证据,让代码验收从“看代码”走向“看结果”,也让我们对 AI 生成的代码多一些信心。

01

业务背景与痛点

在医疗相关业务的研发过程中,我们一直在探索 AI 如何参与研发全流程,减少需求开发中的重复工作和人工介入。围绕这个方向,我们自建了一个 OPT(One Person Team)平台。OPT 平台是以 CodeBuddy 等 CLI 为底层运行时打造的人与 Agent 协同工作的平台,通过多个 Agent 组成的小队,可以协同完成需求分析、规划、开发等工作,让 AI 从辅助编码参与到完整的需求交付中。随着 AI 参与得越来越深,后端需求开发的节奏也发生了明显变化。现在,很多需求分析、方案设计和编码的工作都可以交给 AI 完成,“把代码生产出来”正在变得越来越容易。但另一个问题也变得更加突出:代码写得更快了,却更难快速判断它是否真的能用。

后端代码的采纳和验收并不等于“代码已生成”,也不等于“接口能调通”,往往涉及复杂的业务规则和上下游流程。一个接口返回 200,只能说明它在当前参数下完成了一次调用;但需求逻辑是否正确、边界条件是否覆盖、老数据是否兼容、异步任务是否生效,以及日志和数据库状态是否符合预期,仍然需要进一步验证。也就是说,AI 可以很快把代码写出来,但开发仍然需要花大量时间人工确认改了什么、影响了什么、应该怎么验,并最终判断这次修改是否确实满足了需求。

这就形成了一个速度差:AI 代码生成速度 >>> 人工需求验收速度。

随着 AI 生成代码的比例越来越高,验收逐渐成为需求交付中的新瓶颈。因此,我们要解决的不是“如何让 AI 再多写一点代码”,而是:当 AI 已经把代码生成速度提上来之后,如何帮助开发更快、更稳地判断这段代码是否真的可用。

这也是这次实践的出发点:我们在 OPT 的需求交付小队中补上了一个后端验收 Agent,让 AI 在完成需求分析、规划和开发后继续向后走一步,参与代码发布、测试执行和结果分析,并通过接口、业务状态、日志、数据库等实际证据完成验收判断,进一步补齐 OPT 需求交付链路。

02

解决方案与案例详解

接下来,将结合实际案例,拆解后端验收的完整工作过程,具体看看这套方案是如何工作的。

 2.1 核心能力 Skill 拆解

api-acceptance 是这套后端服务预验收能力的核心工具。接下来围绕 api-acceptance 的主流程,拆解它如何完成一次后端需求预验收。其主流程可以拆成五个阶段:

在拆解五个阶段之前,先说明一个贯穿全流程的底层设计:api-acceptance 并不是遇到任何异常都立刻失败,也不会把所有受限项都包装成成功,而是把异常分成“硬阻塞”和“软失败”两类处理。

硬阻塞保证 Agent 不越过必要的人机确认和环境前提;软失败则让 Agent 在发布失败、spec 缺失、日志暂不可用等受限情况下,继续完成变更分析、场景生成、静态 Review 或风险标注。核心原则就是:能验证的尽量验证,不能验证的诚实标注,不要把受限项伪装成通过。

 2.1.1 第一阶段:变更接口分析,先确定“验哪里”

传统人工自测通常会先凭经验列几个接口:这个需求改了某个 handler,就验这个 handler;改了某个 service,就找调用它的接口。但这种方式的问题是,需求影响并不总是停留在改动文件本身。一个字段类型变化、一个枚举范围收紧、一个错误码语义调整,都可能影响已有调用方和边界场景。

所以第一阶段要做的事情,是从代码变更反推验收范围。

Agent 会基于 git diff、需求描述、分支信息和接口定义,识别变更文件、变更函数、调用链和入口接口,最后形成测试接口列表。

同时,它会标注需求契约与兼容性风险。兼容性风险可以分成三类:

变更接口分析越准,后面的 Gherkin 场景和验收报告越不容易跑偏。它决定的不是执行速度,而是验收方向。

以下是案例输出的变更接口分析报告:

 2.1.2 第二阶段:编译发布及接口验证,确认“能否验”

确定验收范围之后,下一步不是马上判断需求对不对,而是先确认接口具备实际验证条件:服务能不能编译?能不能发布?目标环境能不能访问?接口能不能用最小参数调通?接口契约是否与定义一致?

在我们的实践中,医疗业务通过内部研发平台支撑应用的构建、部署等运维全生命周期管理。我们在此之上封装了命令行工具,验收 Skill 通过它对接平台,完成服务的编译并发布到目标环境。

环境选择上,优先使用 Agent 任务专用的隔离环境,其次是个人开发环境,最后才考虑公共测试环境。这样可以减少环境污染,也便于复现问题。

当环境、配置和依赖都就绪时,发布及接口验证可以顺利完成。

以下业务案例中,Agent 查询到可用的个人开发环境后,编译并发布服务,随后逐一验证了变更涉及的接口连通性和契约一致性。全部接口均返回正常,顺利进入后续 Gherkin 测试阶段。

接口连通性验证通过,并不代表需求逻辑已验证通过,但它标志着验收从“准备阶段”正式进入“业务验证阶段”。后续 Gherkin 场景的真实执行,才真正开始检验需求逻辑是否被正确实现。

 2.1.3 第三阶段:Gherkin 测试,设计并执行“怎么验”

当接口具备验证条件后,最关键的问题变成:到底怎么验?

如果只让 Agent 根据接口定义自行执行,很容易出现两类问题:它可能漏掉需求里的业务预期,也可能按错误预期跑出一份看似完整的报告。因此引入 Gherkin 和校正流程,用 Given-When-Then 把需求拆成可读、可确认、可执行的接口场景。

Gherkin 场景主要覆盖三类:

这里有一个关键硬阻塞点:Gherkin 场景确认报告必须人工确认后,才能进入真实执行。因为 Gherkin 承载的是“需求预期”,预期一旦错了,后续报告反而更有迷惑性。确认时重点看前置条件、接口选择、关键参数和 Then 预期;有问题就先让 Agent 修正场景。

以下是案例输出的 Gherkin 场景确认报告:

确认完成后,Agent 会把每个 Scenario 映射成接口调用序列,构造业务参数和鉴权参数,再执行接口请求并记录结果。

参数构造最容易卡住,所以要先明确来源优先级:真实数据优先,LLM 推理只做兜底。为了让这一阶段跑得更稳,需要重点建设业务测试知识库,提供鉴权说明、常用测试账号、测试数据构造方法、数据获取方式,以及必要的业务字段知识等。对 Agent 来说,缺少这些上下文时,它不是不能继续,而是容易进入 WARN、SKIP 或无法判定。

2.1.4 第四阶段:TAPD 预测试,判断哪些用例后端可验

TAPD(Tencent Agile Product Development,腾讯敏捷产品研发平台)是腾讯自主研发的一站式敏捷研发协作与项目管理平台。TAPD 关联用例通常由测试同学确认,能补充 Gherkin 之外的需求路径和边界场景。但不是所有 TAPD 用例都适合由后端接口独立完成,所以 api-acceptance 在读取 TAPD 关联用例后,需要先做范围分类:

这一阶段主要是增加用例来源,作为一种补充验证手段,将测试阶段可能保留的问题前置在开发验证阶段。

2.1.5 第五阶段:验收结果输出,用证据链回答“怎么判”

最后一步是输出验收结论。这里最需要避免的误区是:接口返回 code=0 就写通过。

后端需求验收里,“表面成功”很常见:

  • 接口返回成功,但字段含义不符合需求;

  • 写接口返回成功,但 DB 状态没有正确变化;

  • 主接口成功,但下游服务失败;

  • 异步消息没有消费,或者日志链路显示副作用没有发生。

因此,api-acceptance 使用 L1-L4 多层证据链:

    L4 静态 Review(最后兜底)
    无法联机验证时,阅读 handler / service / 调用链
    ─────────────────────────────
    L3 链路与异步确认
    下游调用 / 消息 / 异步消费 / 日志
    ─────────────────────────────
    L2 业务状态验证
    配对查询接口 / 数据库查询 / 日志确认
    ─────────────────────────────
    L1 接口返回验证
    响应码 / 字段 / 契约 / 直接接口行为

    以下是一个结合 L1 与 L3 证据进行判断的验证案例:

    场景结果也必须分层表达,最终结论则分成四档:

    最终验收报告会以 HTML 形式呈现,方便人直接阅读、查看证据,以及决策。

    2.2 从单点验收走向完整交付

    前面介绍的 api-acceptance Skill,解决的是一次后端预验收具体怎么做。但在日常需求开发中,它并不是一个独立存在的工具,而是作为后端验收 Agent 的执行内核,被编排到 OPT 的需求交付小队中,成为完整交付链路中的一环。OPT 平台中的一个需求交付小队成员如下图所示:

    需求交付小队按照“需求分析 → 方案规划 → 编码实现 → 代码验收”协同工作。Leader 负责整体调度,各环节由对应的 Agent 执行,人负责确认需求预期、方案和最终交付结论。需求交付小队编排流程如下图所示:

    后端验收 Agent 位于代码实现和代码质量验收之后。只有涉及后端变更时才进入后端验收;验收不通过则将问题打回代码实现,修复后重新验收,通过后输出验收报告。

    对开发来说,只需要负责确认验收预期、查看验收报告并做最终判断。

    在完成后端验收 Agent 能力建设后,我们还持续进行了端侧 E2E 验收 Agent 的探索,包括 H5 和小程序,进一步完善了 OPT 平台上的需求开发交付链路。

    03

    实践效果

    我们将后端代码验收的经验总结沉淀为 api-acceptance Skill,并通过新增后端验收 Agent,补齐了需求交付 Agent 小队的验收能力。至此,OPT 平台上的需求交付小队已打通从“需求分析 → 方案规划 → 功能开发 → 后端验收”的全流程,实现从需求理解到开发验收的完整交付链路。

    作为首个落地业务,目前后端验收 Agent 已运行 160+ 次,覆盖 30+ 个需求、80+ 个入口接口和 800+ 个 Gherkin 场景,其中 20+ 条问题被发现并触发打回修复。按典型后端需求测算,单次验收人工投入预计从 2 小时降至约 20 分钟。从实际落地来看,这套验收能力主要带来了三个变化:验收效率提升、问题发现前置、验收能力复用。

    3.1 提效:人工投入减少 80%

    过去,后端验收会占用较多研发人力,主要消耗在大量琐碎、重复的工作上:准备环境、梳理测试场景、反复调接口、查询日志和 DB、整理测试结果等。单项工作看似简单,但叠加到一个完整需求上,往往需要投入数小时。

    现在,后端验收 Agent 将接管这些重复性工作,研发人员的角色也从“亲自执行验收”转向“确认测试计划 + 审核最终结果”,减少在验收执行环节的投入。以典型中等复杂度后端需求测算,人工验收从约 2 小时降至 20 分钟,单个需求减少约 1.6 小时人工投入,验收环节人工投入预计下降 80%+。

    3.2 提质:问题发现前置到开发阶段

    AI 生成代码涉及多层调用链,仅靠人工 Review 容易遗漏受影响的接口和边界场景。验收 Agent 会结合接口结果、业务状态、日志、DB 等信息进行验证。

    在本业务已完成验收的 30+ 个需求中,共有 10+ 次验收未通过,发现 20+ 条待修复问题并打回修复。修复后再由 Agent 复验,将部分原本可能在联调、测试阶段才发现的问题,提前到开发阶段暴露出来。

    3.3 规模化:验收能力复用

    过去验收方式比较依赖个人经验,验了什么、怎么看结果往往难以复盘。我们将相对固定的验收步骤沉淀为 api-acceptance Skill,由验收 Agent 按统一方式执行并输出报告。

    本业务已完成首轮业务验证,覆盖 30+ 个需求、80+ 个入口接口和 800+ 个 Gherkin 场景。现在,这套验收方法已经推广到其他医疗相关业务中使用,减少每个业务重复摸索验收方法的成本。

    04

    一些体会

    AI 编码提升了“生成代码”的效率,但代码是否能够采纳,仍需要通过更清晰的验收过程来建立信任。

    4.1 确定性先于自动化

    自动化执行前,仍需要先校准业务预期。Gherkin 场景确认不是为了削弱自动化,而是希望让后续执行更可控、更可靠:先明确“要验什么、怎么算对”,再让 Agent 承担重复执行工作。

    4.2 事实密度影响可靠性

    实践中发现,验收效果很大程度取决于真实上下文是否充分,例如接口用例、测试账号、日志、DB、业务知识库等。上下文越完整,Agent 越容易成为工程助手;上下文不足时,就更容易依赖推理和猜测。因此,业务知识库的建设至关重要。

    4.3 尽量用证据链支撑结论

    接口返回成功只是一个基础信号,不能直接等同于需求正确。更稳妥的方式,是结合接口返回、业务状态、链路日志、异步结果和静态 Review 等多层证据,再给出验收判断。

    4.4 边界标注提升可信度

    环境不可用、日志缺失、DB 无权限等问题,在实际验收中很常见。对不可验证的部分清楚标注 WARN、SKIP 或无法判定,比追求表面的“全绿”更有价值。报告边界越清楚,后续协作和补测越有依据。

    4.5 人机协同支撑最终判断

    Agent 可以帮助完成初验、收集证据、暴露风险和提出修复建议,但最终是否可交付,仍需要结合业务优先级和发布风险判断。AI 的价值不是替人承担责任,而是帮助人基于更充分的证据做决策。

    当 AI 既能生成代码,也能辅助证明代码为何可信,提效才更有机会走向稳定的交付质量,让 AI 在研发全流程中,从“能生成”走向“敢采纳”。

    -End-

    原创作者|吴思

    感谢你读到这里,不如关注一下?👇

    扫码领取腾讯云开发者专属服务器代金券!

    图片

    跳转微信打开

    一文拆解DSH Super-agent双层架构:如何做到后台跑任务、前台继续接活

    2026年11月10日 08:45

    原创 朱进 2026-11-10 08:45 广东

    关注腾讯云开发者,一手技术干货提前解锁👇

    开发者公众号专属群聊

    扫码加入获取更多一手教程、科技前沿报告

    10 月 31 日晚,DeepSeek Harness 团队在公众号发表长文《Super-agent 设计探索:迈向更自主的 Agent 系统》,同时开源了原型项目 dsh-superagent-prototype。文章里有个内部实例的画面:团队成员在群聊里反馈软件问题,没有人 @ AI,系统自己认出这是个缺陷,在后台复现、定位根因,找到简单修法后直接提交了修复 PR。

    先把性质说清楚:这不是产品发布。团队在文首特意声明,这是一篇面向工程实践的架构思路探讨,不涉及现有产品功能。也正因为如此,它把问题定义和系统设计讲得很干净,值得逐层拆开看。

    01

    瓶颈换了位置

    过去两年,模型干单个任务的能力涨得很快。以编码场景为例,Coding Agent 完成一项复杂工作需要人工介入的环节越来越少,人的角色从"盯着每一步"上移到"定目标、验结果"。

    麻烦出在多任务。主流 Agent 的工作单位仍然是单次会话(Session):一个人同时推进几项工作,就得手动开几个 Session,来回切换,还要自己记住每个 Session 里说过什么。DeepSeek 团队给了一个观察数据:一个人通常只能同时跟进 3 到 5 个活跃会话。

    于是瓶颈换了位置。单任务的上限取决于模型能力,多任务的上限取决于人的注意力。模型越强,这个矛盾越尖锐。活儿 AI 都能干,可安排活儿、同步上下文的还是人脑。

    图 1 | 瓶颈的转移:单任务时代卡在模型能力,多任务时代卡在人的注意力

    Super-agent 要解决的就是这一件事:把会话管理和上下文同步从人手上移到系统层。人只负责目标与验收,调度和执行交给系统。团队把这个形态和支撑它的架构统称为 Super-agent。

    02

    Super-agent 是什么

    一句话定义:打破 Agent 与单次手动会话的绑定,让它成为一个跨会话保持上下文、同时推进多项复杂任务、互不干扰的连续实体。

    它有四个特征:

    • 连续:在 IM、GitHub、邮件等熟悉的工作界面直接交互,感觉始终只有一个 Agent。先在 IM 里拍板方案 A,随后在 GitHub PR 评论里改成方案 B,它能理解并调整方向,不需要人去想"这个上下文在哪个 Session 里"。

    • 高效:交互响应快,多个复杂任务并行推进。不必等上一个命令跑完,就能接受下一条指令。

    • 主动:持续观察环境事件,值得处理的事主动推进,不需要介入时保持安静。

    • 持久:始终在线、直接接入真实工作环境,长期运行中遇到异常能自动恢复。

    图 2 | 连续、高效、主动、持久:四个特征与五组支撑模块

    团队自己也说得很直白:整套设计没有提出全新的理论,做的是把计算机系统里经典的工程思想——调度、缓存、存算分离、看门狗、投机执行——搬进 Agent 系统。具体实现会随技术演进,但设计思路有长期参考价值。下面逐个看这五组模块。

    03

    双层架构:Router 管协调,Worker 管干活

    先看为什么要拆两层。两个极端都有问题:所有消息进同一个会话,上下文连续,但执行串行阻塞,不同任务的细节互相污染;每条消息新开一个会话,并发好做,全局协调和交互一致性又丢了。

    Super-agent 把"维护全局连续性"和"高并发执行"拆到两个层级:

    Router 是持续运行的全局协调节点,统一承接人类交互与跨任务协调:接收群聊、GitHub、邮件等多渠道消息,识别任务归属并分派,维护跨任务的全局上下文,统一向用户回复。它不执行具体任务,甚至可以不配备 Bash 工具,职责边界直接焊死在系统结构里。

    Worker 是一组相互隔离的会话,各自维护独立上下文,并行执行问题复现、代码审查、功能开发等具体工作。Worker 挂载完整执行工具链,通常配置能力最强的模型;它不直接与人类交互,状态和结果汇报给 Router,由 Router 统一对外说话。任务复杂时,Worker 还可以继续调用 Subagent。

    图 3 | 双层架构:Router 统一对外,Worker 隔离并发,绿色虚线为订阅直通

    这个设计和常见的多智能体团队形态相似,差别主要在职责边界:Router 不必成为深入参与每个子步骤的技术主管,具体的技术判断留在 Worker 内部。职责边界由系统结构承接,不指望模型临场决定要不要委派。这一点很关键,它把"会不会放权"从模型的发挥题,变成了架构里的确定约束。

    开源原型里,工作被组织成 Ticket:每个任务关联自己的执行会话与目录,面板集中显示等待回答、等待审查、受阻的事项。任务的进度和讨论可以延续,用户不再用聊天窗口的位置来记住哪件事推进到哪了。

    04

    事件驱动:先代码过滤,后模型判断

    驱动 Agent 的主要输入,不再只是人类逐条键入的提示词,而是群聊消息、邮件与日程提醒、代码评审评论、CI 运行结果这类半结构化环境事件,DeepSeek 把它们统称为 Trigger。

    真实环境的特征是高噪音、低触发率:绝大多数群聊消息根本不需要 AI 介入。如果每条消息都过一遍大模型,成本和延迟都撑不住。团队的解法借鉴了操作系统的 Fast Path / Slow Path 思想,做两级过滤:

    程序层策略(Fast Path)用确定性代码做快速准入检查(来源、接收范围、准入条件),在调用模型前滤掉大部分无关消息;语义层策略(Slow Path)把候选事件交给 LLM,依据提示词里编写的策略和上下文判断是否需要行动。Slow Path 同时是个自然语言扩展点:团队用大白话写"什么值得做",比改代码灵活得多。

    图 4 | 两级过滤与订阅直通:新任务走 Slow Path 进 Router,已订阅 Thread 直接送达 Worker

    事件路由上同样有省钱的细节:全局 Router 只负责新任务的冷启动与跨任务协调,已确定归属的后续事件由程序直接发往对应 Worker。同一个 PR、IM 话题或邮件串构成 Thread,由接手的 Worker 订阅,后续评论和 CI 结果直达,不再劳烦 Router。

    两个值得记住的约束:其一,Thread 与 Worker 是多对多关系——一个任务可以跟踪多个讨论,一个讨论也可能关联多个任务;其二,订阅只提供信息,不自动赋予新的操作权限,超出当前任务范围的要求仍要重新走分派。原型里还用 Mandate 限定每个任务的授权范围,防止 Agent 擅自扩权。

    对于"主动接活"这件事,原型默认采取观察模式:系统先记录"本来会接什么任务",跑一段时间确认推断可靠后,再放开自动执行。这是一个灰度思路,主动性也得先证明自己。

    05

    持久在线:存算分离加看门狗

    "始终在线"说起来简单,工程上要拆成三件事:计算放哪、状态存哪、环境跑在哪。

    Super-agent 的答案是把 Agent Loop 的计算、会话状态和执行环境解耦:执行循环放在云端,会话状态存入数据库,执行环境保留在用户本地设备,本地只部署一个负责执行命令、返回结果的轻量 daemon。你的电脑合上盖子,云端 Agent 的任务状态还在;设备重新上线,daemon 接着跑。

    长期运行还绕不开一个老问题:Agent 会卡死、陷入无效循环、偏离目标,甚至程序本身崩掉。DeepSeek 的处理方式是给 Agent 配一个独立的 Watchdog。这个设计借鉴嵌入式系统里的看门狗定时器:由独立进程监督其他 Agent,检测程序故障和目标偏离,并尝试介入修复。监督者和被监督者分开部署,避免"自己检查自己"的盲区。

    图 5 | 存算分离:云端算、库里存、本地跑,Watchdog 独立兜底

    06

    两个精巧的小设计

    异步 ReAct Loop

    传统 ReAct 循环里,工具调用是同步的:启动一个十几分钟的训练任务,整个会话就干等着。Super-agent 把耗时工具调用改成异步的 start() 和 stop():Agent 启动后台任务后立即返回 Started 状态,结果随后作为新事件回流进会话。前台对话不阻塞,用户随时能插进新指令。团队说明这个机制已在 DeepSeek Harness 里实现,但默认没开——发布节奏上相当克制。

    投机执行

    借鉴 CPU 的投机执行思想:结果是否被采用尚未确定时,先在后台提前尝试,有价值再交付,没有就丢弃。内部落地的策略叫"静默复现并修复":群里有人反馈 Bug,AI 先在后台复现、分析根因,确认问题存在且找到简单修法才提交,否则保持安静。宁可白干,不可打扰。这套机制同样适用于个人助手:收到会议邀请,先核对日程冲突、整理背景资料、备好回复草稿,等你确认。

    图 6 | 异步 ReAct 让会话不阻塞;投机执行让 AI 宁可白干也不打扰人

    顺带一提上下文管理。跨会话、跨任务的长程记忆靠两个机制:Inline & Spill 把近期大概率用到的信息直接放进模型上下文窗口,超出预算或低频的内容留在窗口外按需读取;Chain of Recall 则利用 Trigger、Thread、Worker Session 之间的引用关系,让模型沿关联 ID 一步步找回历史任务信息。前者控制"现在装多少",后者解决"过去怎么找回来"。

    07

    数字说话:实验结果与代价

    DeepSeek 公布了初步实验数据,在约 300 条消息、20 项工作请求的模拟协作环境中,每种配置重复测试 5 次:

    图 7 | 完成时间对比:P95 口径下,Super-agent 比单 Session 方案快约一倍

    另有两个消融数据,恰好说明这套架构不是免费的午餐:

    • 去掉订阅直通后,Router 决策次数增加约 30%,读缓存 token 从 2323 万涨到 3177 万,涨幅约 37%。事件路由机制在省真金白银。

    • Router 批处理把单个决定分摊的推理时间从 6.4 秒降到 1.6 秒,突发消息洪峰靠攒批扛住。

    也就是说,Super-agent 是拿更多的 token 换时间和稳定性,而且实验基于合成负载与简化环境,只是初步参考。团队能把代价和局限一起摆出来,比只报喜的论文诚实不少。

    08

    几点思考

    算法上没什么新东西,赢在系统工程。Router/Worker、事件总线、任务队列、缓存、看门狗、投机执行,全是分布式系统和操作系统里跑了几十年的老东西。Super-agent 的价值在于把它们重新组合进 Agent Runtime,让 Agent 摆脱单次对话窗口的生命周期限制。这提醒我们:Agent 的下一程竞争,可能不在模型榜单,而在谁先把"操作系统"那一层做扎实。

    职责边界写进结构,比写进提示词可靠。Router 不装 Bash、Worker 不直接对人说话、订阅不给权限、Mandate 限定授权范围。每一处都是用架构约束代替对模型自觉的期待。当你不能确定模型每次都会做出正确选择时,就把它物理上做不到的事从能力清单里删掉。

    主动性的落地路径是灰度。观察模式先记录"本来会接什么",验证可靠后再放开执行;投机执行宁可白干也不打扰。这两个设计合在一起,回答了"AI 主动干活"最容易被质疑的问题:怎么保证它不乱来、不烦人。答案没押在更强的对齐训练上,押在了更保守的交付策略上。

    个人助手和商业场景,底层是同一件事。文章里反复强调:个人助手与软件开发等商业 Agent,只要目标都是持续在线、并发响应环境事件,底层架构就是相通的。这也解释了为什么各家 Coding Agent 厂商都在往"长驻、多任务、事件驱动"方向走:形态先在研发场景跑通,再泛化到更广的个人助理市场。

    09

    结语

    Super-agent 没有发明新理论。它做的事,是把一个正在发生的趋势说清楚了:模型能力足够强之后,Agent 系统的设计重心从"怎么把单件事做好"转向"怎么同时管好很多件事"。会话管理、上下文同步、异常恢复这些以前由人脑承担的成本,正在被一层系统架构接走。

    人剩下什么?定目标,验结果。听起来轻松,实际上是把更大的判断责任压到了人这边——验收能力会成为新的瓶颈吗?这个问题,可能要等下一篇文章来回答。

    参考资料

    • DeepSeek Harness 团队公众号:《Super-agent 设计探索:迈向更自主的 Agent 系统》(2026-10-31)

    • 开源原型:github.com/deepseek-ai/dsh-superagent-prototype(MIT 协议)

    • 智东西:《DeepSeek 又开源了!公布 Super agent 架构》(2026-11-01)

    • 凤凰网科技:《DeepSeek 提出 Super-agent 架构设计》(2026-10-31)

    • 腾讯云开发者社区:《DeepSeek 开源 Super-agent 架构》(2026-11-01)

    -End-

    原创作者|朱进

    感谢你读到这里,不如关注一下?👇

    扫码领取腾讯云开发者专属服务器代金券!

    图片

    跳转微信打开

    为什么AI干得总是差点意思?教你怎么把需求一次说清楚

    2026年11月6日 08:45

    原创 袁俊晓 2026-11-06 08:45 广东

    关注腾讯云开发者,一手技术干货提前解锁👇

    开发者公众号专属群聊

    扫码加入获取更多一手教程、科技前沿报告

    提示词工程的关键,不在于寻找一句万能指令,而在于清晰表达任务、组织必要上下文,并用明确的结构和约束降低歧义。本文从基础概念、表达格式和实用技巧出发,梳理一套可直接应用于日常 AI 使用与应用开发的提示词方法。

    01

    大语言模型的本质是什么?

    本质是一个通过海量数据训练得到的预测引擎,用来预测“在给定上下文,下一个最合理的 token 是什么”。

    它接收一段文本作为输入,然后根据上下文预测下一个最可能出现的 token。模型每次生成一个 token,并将其追加到当前序列中,再继续预测下一个 token。因此,每一步生成都依赖于前文上下文和模型训练中学到的模式。

    02

    什么是提示词工程?

    提示词就是我们给到大模型的输入,它的作用是设法引导大模型生成的下一个 token 符合我们的预期。

    提示词工程是通过不断优化输入,提升模型输出质量的系统性方法。它包含三个关键维度:

    1. 质量维度:输出的内容专业、完整和有价值,让人感觉“说到点子上”。

    2. 稳定性维度:在不同场景和时间下产生可预期的一致表现,让人感觉“靠得住”。

    3. 正确性维度:信息准确、可信,减少产生虚假或误导性内容的情况,让人感觉“说得对”。

    提示词工程的局限

    提示词工程不是万能的。它不能突破模型能力的上限,也不能保证绝对正确;它只能在模型已有的能力范围之内,把成功的概率推高。

    03

    提示词工程的目标受众是谁?

    提示词工程主要面向两类人:

    • 使用 AI 工具的人?

    • 制造 AI 工具的人?

    在 AI 应用开发中,提示词工程尤其重要,可以从两个角度理解:

    • 从 AI 应用角度:模型响应用户输入(User Prompt),在系统提示词(System Prompt)的约束下生成回复(Assistant)。

    • 从产品角度:通过产品设计来设置用户使用的方式,以及模型响应的方式。

    04

    常见的几种角色提示词

    常见的对话消息包含 System、User、Assistant 三种角色。

    System(系统)

    • 设置对话的基本规则和角色定位。

    • 定义 AI 助手的性格、行为准则、回复风格等。

    • 通常由开发团队预设,用户一般看不到。

    • 例如:“你是一个乐于助人、专业的 AI 助手……”

    User(用户)

    • 对话的发起者和提问者。

    • 用户每次输入的问题或指令。

    • 用户提供需求、问题、指令或对话内容。

    • 例如:“帮我写一封邮件”“解释一下……”

    Assistant(助手)

    • AI 的回复角色。

    • 即助手每次给出的回答。

    • 基于系统设定和用户输入生成回应。

    System Prompt 与 User Prompt 的区别

    在开发 AI 应用时,系统提示词用于设置人设与回复逻辑;用户提示词用于表达用户当次提出的问题和需求。两者共同影响大模型的响应。

    05

    常见的参数设置

    大多数 LLM 提供丰富的参数,用于控制输出生成的方式。有效的提示词工程离不开对这些参数的合理设置,这些参数通常通过 API 调用的形式进行设置。

    参考资料:DeepSeek Chat Completion API 文档

    https://api-docs.deepseek.com/zh-cn/api/create-chat-completion/

     5.1 一输出长度(Output Length)

    输出长度即模型响应中生成 token 的数量。输出 token 越多,模型计算开销越大,响应时间越慢,成本越高。

    需要注意的是,缩短输出长度并不会让模型“写得更简洁”,它只是在达到指定长度后停止生成。如果想获得短内容输出,还需要通过提示词引导模型尽早收敛。

    在某些提示词技巧中,限制输出长度尤为重要,比如 ReAct 技法中,模型容易在目标输出后继续生成冗余内容。

     5.2 采样控制(Sampling Controls)

    LLM 并不是“预测一个确定 token”,而是对所有可能的下一个 token 给出概率分布,然后从中采样决定最终输出。控制采样方式的关键参数包括 temperature、top_p。

    Temperature(温度)

    temperature 控制采样的随机性:

    • 值越低,输出越确定;值越高,结果越多样、越随机。

    • temperature = 0 代表贪婪解码(greedy decoding),总是选取概率最高的 token。

    • 低温度意味着偏向确定输出,高温度则允许更多不确定性,适用于需要创造性结果的场景。

    以下是不同任务的温度参数示例:

    注:不同模型和接口的参数行为可能不同,具体配置应以所使用模型的官方文档为准。

    Top-P(核采样)

    使用时需要注意:

    • temperature、top_p 不建议统一调整,它们之间相互影响。

    • 若 temperature = 0,top_p 会被忽略。

    • 若 top_p 接近 0,模型通常只选取最高概率的 token,其他设置也可能被弱化。

    06

    如何才能写出好的提示词

    实践中,可以按以下顺序着手:

    1. 第一,把任务说清楚,给足上下文信息。

    2. 第二,使用最好的模型。

    3. 第三,才是提示词技巧的使用。

    07

    提示词有哪些表达方式?

    常见提示词格式包括:自然语言、XML、MD(Markdown)、JSON、伪代码等。实际使用时可以根据任务复杂度选择一种格式,或者结合起来使用;核心是结构化表达,不要产生歧义。

     7.1 自然语言

      你是一个翻译专家,请把我说的话翻译成英文。
      注意不要回答问题,只输出翻译结果。
      • 优点:直观、容易理解,适合普通用户。

      • 缺点:可能存在歧义,结构性较差。

      • 适用场景:简单任务。

       7.2 Markdown

        # 角色
        翻译专家


        # 任务
        把我说的话翻译成英文


        # 要求
        不要回答问题,只输出翻译结果

        Markdown 天生用来表达文章结构:

        • # 代表大标题,## 代表副标题,可以明确表达逻辑上的层级关系。

        • 无序列表表达同级并列关系。

        • 有序列表表达同级递进关系。

        • 表格表达数据或属性的对比和归纳。

        Markdown 是常用的提示词表达格式,能够兼顾简单和复杂任务。它的结构层级明确,便于区分不同内容的边界。

         7.3 XML

          <角色>
          翻译专家
          </角色>
          <任务>
          把我说的话翻译成英文
          </任务>
          <要求>
          不要回答问题,只输出翻译结果
          </要求>
          • 优点:结构清晰、层次分明、便于程序解析。

          • 缺点:较繁琐,普通用户理解有一定难度。

          • 适用场景:复杂任务场景、表达结构化内容。

           7.4 伪代码

          以实验判断为例,按顺序判断数据量、连续负向、近期趋势、累计收益、波动等条件,再返回是否停止实验及原因。

          伪代码是一种用类似程序控制逻辑的方式来编写提示词的格式,常用于复杂任务、多个条件判断、Agent Prompt 以及 Workflow 场景。它通过 if / else / loop 等逻辑结构,显式地告诉模型在不同条件下应如何行动,从而尽可能减少歧义。

          • 优点:结构清晰、层次分明,便于表达判断逻辑。

          • 缺点:相对繁琐,普通用户理解有一定难度。

          • 适用场景:复杂任务、多条件判断、Agent 和 Workflow。

           7.5 JSON

            {
              "角色": "翻译专家",
              "任务": "把我说的话翻译成英文",
              "要求": "不要回答问题,只输出翻译结果"
            }
            • 优点:结构化程度高,便于数据交换。

            • 缺点:不太直观,输出较繁琐。

            • 适用场景:结构化输出。

             7.6 Jinja

            指出,在智能体开发平台中 Jinja 很常见,例如 Coze、Dify;它支持逻辑语法。

              {% set language = "英语" %}
              你是一个翻译专家。
              请把我说的话翻译成 {{ language }}。
              注意不要回答问题,只输出翻译结果。

              实际使用时,应根据任务复杂度选择合适的格式,也可以组合使用。核心是结构化表达、明确内容边界,尽量避免歧义。

              08

              提示词构成

              为了系统化地向大模型提供明确的背景和目的,我们通常会使用一些 Prompt 框架来规范化 Prompt。比如给大模型设定角色、提供足够的背景信息、交代清楚要执行的任务和内容输出的约束条件。

              这一类提示词框架非常多,核心是引导我们一次性把话说完、说清楚,这样大模型才能更准确地完成任务。

              一个实用的提示词框架可以包含四个部分:

              • 角色

              • 背景信息

              • 任务

              • 约束

              示例:生成待办事项列表组件

                # 角色
                你是一位资深前端开发工程师,精通现代 React(v18+)和 TypeScript,
                并熟练使用 Tailwind CSS 进行快速 UI 开发。你注重代码的可读性、
                可维护性和最佳实践。


                # 背景
                我正在开发一个个人生产力管理应用的核心模块。当前的需求是实现一个交互式待办事项列表。
                - 用户故事:作为一名用户,我可以添加新的待办事项、将其标记为完成/未完成、删除事项,并能一眼看清哪些事项已完成。
                - 技术栈:项目已配置好 React + TypeScript + Vite + Tailwind CSS。
                - 数据状态:待办事项的数据结构计划使用一个 TodoItem[] 数组,每个事项包含 id(唯一标识)、text(内容)、completed(是否完成)。


                # 任务
                请生成实现此功能组件的完整、可运行的代码。具体需要:
                1. 创建一个名为 TodoList.tsx 的功能组件。
                2. 使用 React 的 useState Hook 来管理待办事项列表的状态(初始状态可包含 2–3 个示例事项)。
                3. 实现以下交互功能:
                   - 添加事项:通过输入框和“添加”按钮提交新事项。
                   - 切换完成状态:点击事项文本或旁边的复选框,切换其 completed 状态。
                   - 删除事项:每个事项旁有一个删除按钮,点击后将其从列表中移除。
                4. 根据 completed 状态动态更新事项样式(例如,已完成事项文本有删除线、颜色变浅)。


                # 约束
                请严格按照以下要求组织回答:
                - 代码实现:提供 TodoList.tsx 的完整代码。代码需包含清晰的类型定义(TypeScript 接口)、详细注释(说明关键逻辑和状态变化),并保持 ESLint 友好的格式。
                - 输出格式:请使用注明语言为 tsx 的 Markdown 代码块。

                09

                提示词的最佳实践

                 9.1 提示词要清晰、直接和详细

                这里有两个值得注意的要点:

                1. 大模型对清晰、直接和详细的提示词反馈最好。

                2. 把大模型当作一个非常聪明的新员工。让新员工干活时,需要非常明确的指示,提供充足的背景信息,才能更好地完成交代的任务。

                示例:营销邮件

                BAD

                为我们的新 AcmeCloud 功能写一封营销邮件。

                GOOD

                你的任务是为我们的 Q3 AcmeCloud 功能发布制作一封有针对性的营销电子邮件。

                指示:

                1. 目标受众:从本地部署升级到云的中型科技公司(100–500 名员工)。

                2. 核心功能:突出 3 个关键新功能——高级数据加密、跨平台同步和实时协作。

                3. 语气:专业但平易近人,强调安全性、效率和团队合作。

                4. CTA:包括明确的行动号召,例如免费 30 天试用、优先入职。

                5. 主题行:少于 50 个字符,提及“安全”和“协作”。

                6. 个性化:使用 {{COMPANY_NAME}} 和 {{CONTACT_NAME}} 变量。

                7. 结构:主题行、正文(150–200 字)、CTA 按钮文本。

                 9.2 提供示例

                通过在提示中提供精心设计的示例,可以显著提高大模型输出的准确性、一致性和质量。这种技术被称为单一样本学习(One-shot)、少量样本学习(Few-shot),对于需要结构化输出或遵守特定格式的任务特别有效。

                示例有什么作用?

                1. 准确性:减少对指令的误解。

                2. 一致性:示例帮助固定统一的结构和风格。

                怎样的示例才是好的例子?

                • 相关性:示例应与你要处理的问题相关、类似、有可比性。

                • 多样性:示例要覆盖各种场景,特别是边界情况,并有足够区分度。

                • 清晰性:示例可用 <example>、<input>、<output> 等标签区分,让大模型更好地理解。

                例如,在客户反馈分类任务中,可以要求模型使用“UX/UI、性能、功能请求、集成、定价和其他”等类别,并评估情绪(正面/中立/负面)和优先级(高/中/低)。示例反馈为:“新仪表板简直没法用!加载慢得要命,找个导出按钮还得满世界乱翻!”

                还可以用翻译任务演示如何用 <examples>、<example>、Q、A 等标记固定输入输出格式。

                 9.3 通过示例让 JSON 输出更稳定

                让 JSON 输出更稳定,可以注意三点:

                1. 给结构模板:模板必须写清楚,例如:

                    { "intent": "", "reason": "" }
                                                                                1. 告诉模型禁止输出解释:例如,不要输出模板之外的任何文字,否则模型有时会加一句“以下是 JSON 输出”。

                                                                                2. 用“必须 严格 不可缺失”等强约束语言:使用“必须”“严格”“不可缺失”等明确约束,有助于提升输出稳定性。

                                                                                例如,可以要求模型必须使用指定 JSON 格式,字段不可缺失,且禁止输出模板之外的文字:

                                                                                  {
                                                                                    "confidence": 0.0,
                                                                                    "intent": "SUPPORT | FEEDBACK | CHAT",
                                                                                    "reason": "简要说明分类依据"
                                                                                  }

                                                                                   9.4 设定角色

                                                                                  通过系统提示词给模型分配角色,比如“你是一名高级 Java 开发工程师”“资深管理咨询大师”等。认为这个技巧很好用,几乎可以用于很多场景。

                                                                                  角色设定主要影响三个方面:

                                                                                  • 准确性更高:在法律分析、财务建模、数学推导等复杂、专业度高的场景里,设定角色往往能改善模型表现。

                                                                                  • 语气和风格更贴合:角色提示词会影响沟通方式,例如 CFO 简洁、冷静的表达风格,或文案写手有创意、有情绪的风格。

                                                                                  • 改进专注力:通过设置角色背景,让大模型更容易围绕任务要求回答,而不是东拉西扯。

                                                                                  这是因为:一个具有代表性的角色,背后对应着大量与该角色相关的知识、思维方式、行为习惯和表达风格。角色越具体,越有助于缩小问题范围,让 AI 更专注地解决任务。

                                                                                  例如,软件许可协议分析可以这样对比:

                                                                                  • BAD:分析这份软件许可协议中的潜在风险。

                                                                                  • GOOD:说明企业背景,并要求重点分析赔偿、责任限制和知识产权所有权条款,留意不寻常或令人担忧的条款,同时提供标准合同进行比较。

                                                                                   9.5 使用 XML 标签或分隔符号区分单元

                                                                                  在构建复杂的 Prompt 时,采用特定分隔符来界定不同内容单元,可以增强 LLM 对 Prompt 的正确解析。随着任务复杂度增加,合理使用分隔符越有帮助。

                                                                                  分隔符可以选择自然语言中不常见、辨识度高的字符组合。它没有固定规则,关键是让模型能清楚识别不同内容区域的边界,而不把分隔符当作普通标点。

                                                                                  例如,在协议审查任务中,可以用标签分别标出指令、标准合同和待审查合同:

                                                                                    <standard_contract>
                                                                                    {{STANDARD_CONTRACT}}
                                                                                    </standard_contract>


                                                                                    <instructions>
                                                                                    1. 分析赔偿条款
                                                                                    2. 分析责任限制
                                                                                    3. 分析知识产权所有权
                                                                                    4. 注意不寻常或令人担忧的条款
                                                                                    5. 与标准合同进行比较
                                                                                    </instructions>


                                                                                    <contract>
                                                                                    {{CONTRACT}}
                                                                                    </contract>

                                                                                    10

                                                                                    引导模型思考

                                                                                    一个实用的做法是:大模型在执行任务前有时间思考,它会表现得更好。特别面对复杂任务(如研究、分析或问题解决)时,添加“在开始回答之前,一步步思考”,可能帮助模型逐步分解问题。这种技术被称为思维链(CoT)提示。

                                                                                    对于推理模型(例如 DeepSeek R1),额外加入 CoT 指令未必会带来明显改善。如果模型的回答仍不理想,应先检查任务描述是否清晰、输入信息是否充分,再有针对性地调整提示词。

                                                                                    可以尝试以下做法:

                                                                                    1. 在指令里加“一步步思考”。

                                                                                    2. 规定步骤:例如写邮件前,先考虑捐赠者的历史捐赠记录、哪些项目内容可能引起共鸣,再结合分析写个性化邮件。

                                                                                    3. 结构化:用标签区分分析和结果,便于检查逻辑问题,也能发现指令是否不够清晰。

                                                                                    示例:撰写个性化捐赠邮件

                                                                                    示例要求根据项目资料和捐赠者资料撰写个性化捐赠邮件:

                                                                                      项目资料:
                                                                                      <program>
                                                                                      {{PROGRAM_DETAILS}}
                                                                                      </program>


                                                                                      捐赠者资料:
                                                                                      <donor>
                                                                                      {{DONOR_DETAILS}}
                                                                                      </donor>


                                                                                      先根据捐赠者的捐赠历史和支持过的活动,判断什么样的信息可能吸引这位捐赠者;
                                                                                      再根据其历史,判断“关爱儿童”项目的哪些方面可能引起共鸣;
                                                                                      最后在 <email> 标签中编写个性化邮件。

                                                                                      类似方法也可以用于投资分析、JSON 检查等任务:通过明确步骤和标签组织输入,让任务流程更清晰、结果更容易检查。

                                                                                      11

                                                                                      提示词链

                                                                                      处理复杂任务时,如果把所有要求都放进一个提示词中,模型的输出可能不够稳定。对于步骤较多的任务,可以拆成多个小步骤,每个步骤用单独的提示词,然后串联起来,把上一步的输出作为下一步的输入。这样能让每一步的输出更加稳定;缺点是会消耗更多时间,但准确率可能提高。

                                                                                      有什么用?

                                                                                      1. 准确性:每个子任务都能获得大模型的注意力,减少错误。

                                                                                      2. 清晰度:更简单的子任务意味着更清晰的说明和输出。

                                                                                      3. 易于调试:更容易识别和修复提示链中的问题。

                                                                                      示例:智能笔记本产品营销

                                                                                      目标:分析新产品“智能笔记本”与竞品 “E-Ink Pad” 和 “Paper Pro” 在价格、核心功能、用户评价和市场定位上的优劣,再提炼三条核心卖点,并撰写面向科技爱好者的营销文案。

                                                                                      可以将任务拆为三个阶段:

                                                                                      示例中的产品资料包括:

                                                                                      • “智能笔记本”:售价 199 美元,功能包括云同步、手写转文本、语音备忘。

                                                                                      • “E-Ink Pad”:售价 249 美元,功能包括护眼电子墨水屏、超长续航。

                                                                                      • “Paper Pro”:售价 159 美元,功能包括实体纸张手感、无需充电。

                                                                                      通过拆分后,每个提示词的职责更加单一,每次任务处理都能更专注,也更容易判断和修复提示词中的问题。

                                                                                      12

                                                                                      设置执行任务的步骤

                                                                                      另一个实用技巧是:把任务执行步骤明确写出来。

                                                                                      示例:小明去爷爷奶奶家

                                                                                      故事大意:小明早上 8 点出发步行去爷爷奶奶家,走了一段时间后,爸爸发现小明忘记带作业,便骑车追赶。追上后爸爸骑车带小明去目的地。题目要求计算到达时间。

                                                                                      可以将背景、目标和执行步骤写进提示词:

                                                                                        # 背景
                                                                                        又到了周日,小明像以往一样去爷爷奶奶家玩。小明于早上八点整步行出发。
                                                                                        走了 12 分钟后,小明的父亲发现小明忘记带作业了,于是骑车去追小明。
                                                                                        等到追上小明后,爸爸决定骑车带上小明。已知小明坐自行车的路程是走路路程的 5 倍。


                                                                                        # 目的
                                                                                        小明什么时候到爷爷家?


                                                                                        # 步骤
                                                                                        1. 先计算小明被爸爸追上时的时间和移动距离。
                                                                                        2. 再计算小明去爷爷家剩余的距离和需要的时间。
                                                                                        3. 最后计算小明到爷爷家的时间。

                                                                                        重点是明确告诉模型先做什么、再做什么、最后需要得出什么结果。对于涉及计算的任务,还应提供完整的已知条件,并在输出后核对计算过程和单位。

                                                                                        13

                                                                                        提示词的防护措施

                                                                                        一种常见的诱导式提示词会让模型“扮演奶奶哄人入睡”,并在故事中试图诱导模型说出 Windows 11 专业版序列号。

                                                                                        这个例子说明:提示词可能通过角色扮演、情绪引导等方式尝试让模型输出不应提供的信息。

                                                                                        14

                                                                                        总结

                                                                                        好的提示词 = 结构化清晰 + 足够的上下文。

                                                                                        提示词工程本质上是“沟通”,用 AI 能听懂的语言说清你的意图。

                                                                                        除了结构化表达和一些最佳实践技巧,更重要的是把要模型做的事情交代清楚,并通过结构化表达帮助模型更好地理解、避免歧义。我们需要提供足够的上下文信息,而上下文工程可以通过多种方式获取信息,例如 RAG、工具调用或技能的使用。

                                                                                        它本质上就是:用 AI 能够听得懂的方式,把我们的意图表达清楚。

                                                                                        -End-

                                                                                        原创作者|袁俊晓

                                                                                        感谢你读到这里,不如关注一下?👇

                                                                                        扫码领取腾讯云开发者专属服务器代金券!

                                                                                        图片

                                                                                        跳转微信打开

                                                                                        一文拆解DeepSeek Harness新架构

                                                                                        2026年11月5日 08:45

                                                                                        原创 陈焕新 2026-11-05 08:45 广东

                                                                                        关注腾讯云开发者,一手技术干货提前解锁👇

                                                                                        开发者公众号专属群聊

                                                                                        扫码加入获取更多一手教程、科技前沿报告

                                                                                         前言

                                                                                        10 月 31 日,DeepSeek 发了一篇《Super-agent 设计探索:迈向更自主的 Agent 系统》,当天就在圈子里传开了。DSH 即 DeepSeek Harness,下文沿用这个简称。

                                                                                        网上的分享不少,但多数停在解读文章本身、复读概念。可如果把里面那些新名词先放下,会发现这条路从"小龙虾"出现之后,大家或多或少都已经试过——DSH 这篇的价值,不在于提出多少新东西,而在于把很多团队脑子里零散的想法,用一套清楚的描述串了起来。所以文章出来之后,很多人的第一反应是:"原来我的 idea 和业界顶尖团队是一致的。"

                                                                                        恰巧,文中的很多观点,和我近半年自己做的一些尝试、调研和思考有重合。下面就从我的视角做一次解读。

                                                                                        01

                                                                                        一个被当成产品问题的问题

                                                                                        抛开架构不谈,DSH 要解决的问题其实很简单。官方文章里有一句话很容易被略过:

                                                                                        据我们观察,一个人通常只能同时跟进 3 到 5 个活跃 Session。在这种设计下,单任务的上限取决于模型能力,多任务的上限取决于人的注意力。

                                                                                        多数人读到这句,会把它归到产品体验上:窗口切换太麻烦、界面不好用,要是有个统一看板把所有任务收拢起来看就好了。

                                                                                        但再往下一层,用户"管理 Session"这件事,很大程度上是从底层 LLM API 延续下来的设计范式——记忆、调度、审批、恢复,全都困在一个会话里:

                                                                                        • 并行上:多个任务同时跑,你得逐个查进度、逐个回结果、逐个补信息。任务并行了,协调却退回给人。所以很多时候让 AI 干活,其实很累。

                                                                                        • 单会话上:长程任务跑起来,聊天记录回答不了全部问题——记忆会被压缩,摘要有取舍。等任务真需要背景时,又得回去问人。

                                                                                        • 外部连接上:IM、会议、文档、App 里的信息,要么人手动告知,要么人手动触发,调度权还在人手里。

                                                                                        于是"3 到 5 个"这件事有了另一种解释:不是人的注意力只有这么多,而是本该由系统承担的记忆、调度、审批、恢复,被交给了人。

                                                                                        用文章里一句话概括:

                                                                                        Session 应当是系统的实现细节,而不应是用户的认知负担。

                                                                                        所以 Super-agent 真正要优化的目标,可以从两个角度看:

                                                                                        • 产品目标:最大化 Agent 产出,最小化人的注意力。靠并行度创造价值,靠弱化 Session 这个产品形态降低认知负担。

                                                                                        • 技术目标:Human out of the loop。没有人干预时,AI 也能自主感知外部信息,完成决策、调度、执行。

                                                                                        要达成这两点,关键不是造一个"更强的 Agent",而是用系统架构,把现在压在人身上的决策、调度、管理接过去。

                                                                                        02

                                                                                        判断的前提:上下文边界与组织

                                                                                        DSH 对 sessionless 的产品形态并没有给出明确定义:是像 Muse 那样的 personal agent 对话框?还是像 TAPD 那样的任务看板?

                                                                                        如果要给 Super-Agent 一个产品形态上的幻想,我脑子里 sessionless 的形态只有一个——"贾维斯"。不妨就假设,未来每个人手里都有一个"贾维斯"App。

                                                                                        任何事只需要一个入口。我说一句"帮我做这个",它去做,在合适的时候答复我;我也可以随时回头问它某件事进展如何。工作、任务、进度追踪,全由它管理、调度、执行。人在这里享受到的,才是 AI 真正带来的便捷。

                                                                                        要实现这个能力,必须引入一个控制层,也就是 DSH 里的 Router。它可以类比主流 Personal Agent 的 Main-Agent,或者干脆就是一个意图识别器:判断一件事值不值得做、该交给谁、做到什么程度算完成。它不执行,只决策。

                                                                                        官方说 Router 可以很轻量,甚至能用小模型。但通读全文,有一个问题始终没说清:Router 凭什么知道你这句话该派给谁?

                                                                                         2.1 sessionless的本质

                                                                                        抛开 Super-agent 这个名号,要弱化sessions这个产品形态,更本质的问题其实是上下文管理本身。

                                                                                        现实世界中,事件的上下文来自四面八方:A 项目下面挂着 A、B、C 三个群,B 项目的代码又散在 A、B、C 三个仓库。而真正决定"这次干活和什么有关"的,是与之相关的工作上下文。Session 只是一个临时的执行过程——就像我在 WorkBuddy 里建一个项目,所有 Session 都复用这个工作区的记忆,我在一个会话里面,让他接着干一件事,不需要做很复杂的交代,他便可以知道我在这个空间下,想干什么,改哪些代码,有什么历史信息。

                                                                                        关于上下文的管理,近半年来基本上大家都在研究这个方向,并不稀奇。DSH这套方案的解法,可以理解为Router就是充当一个管理全局上下文的角色,由他来根据历史信息,来决定这个事件/这条消息,我要派给哪个worker去执行。

                                                                                        但这也是我认为矛盾的点:Router 凭什么知道你这句话该派给谁?

                                                                                        从模型能力看:如果 Router 真的可以很轻量,那小模型能不能担这个责任?我们在单个会话里用旗舰模型聊久了都会出幻觉,何况 Router 要理解、调度、裁决全局的复杂上下文。

                                                                                        从安全边界看:一旦 Router 理解错意图,代价不是"答得不好"。比如一句"帮我把某个临时文件删掉",恰好历史里有同名文件,或者模型幻觉一下,删掉的就可能是重要工作。

                                                                                         2.2 管理上下文边界

                                                                                        所以 Router 可行的前提,不是它多聪明,而是它能看到的上下文“有边界”,即我们需要一个物理概念上或者逻辑概念上的抽象,把上下文限定在一个工作区之间。

                                                                                        针对前面提及的那些偏差——删错文件、派错单——根源往往不是模型能力不够,而是上下文本身没有边界:所有历史、所有项目、所有渠道糊在一起,怎么判断都是猜。

                                                                                        从官方原型给出的事件源看,事件无非来自三类:群聊、GitHub、项目文档,是大家办公场景中很常见的形态,而这些形态天然在逻辑概念上自带上下文的边界。以群聊为例——在工作场景里,A专项群大概率和B专项群讨论的内容不同,一个群本身就是一个自带边界的工作区Context。

                                                                                        开源产品如:Buzz、Raft、Cumora,在人和Agents协作,都把人和Agents的协作范围限定一个逻辑概念上的工作区/群/频道中。

                                                                                        而一旦上下文被限制在可控边界范围内,Router 的决策就变得可行了。

                                                                                        DSH 提到过几种判断事件的策略,比如 Fast Path(代码规则)和 Slow Path(LLM 决策)。我理解这套机制的前提,同样是前面说的可控边界。

                                                                                        如果边界是可控的,比如一个 IM 群,"谁能访问、在哪个项目里访问"就完全可以用代码规则写死,不必交给模型去猜,回归到类似workflow的思路:在什么条件下,满足什么规则,就可以去做某件事。

                                                                                        且后续所有上下文、所有事项都以这个边界建立关联,工作上下文得以延续,前面那些偏差也就能尽量避开。

                                                                                         2.3 链式召唤机制

                                                                                        边界解决的是 Context 怎么组织。但单个 Context 里如果跑的是长程任务,必然会沉淀出远超窗口的上下文。

                                                                                        只靠压缩、没有独立机制维护,早期信息必然丢失。反过来,一股脑全塞进去也不对:挤占窗口、稀释注意力;塞得太少,模型又得反复调工具去读,执行步数上去了。

                                                                                        用DSH官方的话说:浪费上下文窗口,就是浪费模型的智能。

                                                                                        所以 DSH 设计了一个很巧的机制——链式召回。简单来讲就是把上下文窗口当 Cache,系统摘要所有对象都有ID,构成一张引用关系图,每次送给模型先只内联摘要和 ID,Agent 需要细节时,再顺着 ID 逐跳取。而放到 Router 层,这个机制同样能缓解长程任务里"早期信息丢失"的问题。

                                                                                        到这里,第二章回答的是“Router 看到什么”:边界决定它看哪一片,链式召回决定它看多深。但这两件事都还停在“理解”层面——理解完之后,一件事怎么被记住、被交接、换个人还能接着做,是另一套东西。

                                                                                        03

                                                                                        事件如何成为一件工作

                                                                                        前面是站在 Router 的视角,看它面对多个事项时怎么决策。这一节换个视角:从一件工作本身,看它如何被定义、被延续。

                                                                                        以渗透测试为例。如果让 Agent 去做一次渗透,至少需要维护三样东西:渗透目标、当前已知情报、下一步目标拆解。

                                                                                        这其实是仿人类思考的做法——把一件事用数据结构映射出来,得到一个"工作维度上的状态机"。

                                                                                        换一个更日常的例子:@agent 这个 retry 逻辑超时之后会重复扣款,改成幂等的。看看 DSH 是怎么做这层数据映射、怎么定义"一件工作"的。

                                                                                        从表格定义上还是很难看出这里条件的层层扭转,从一个图的角度上来看:

                                                                                        可以发现这些概念各司其职,不是一条龙流水线,而是围绕同一条事件流做不同层面的切分:

                                                                                        • Source 把外部世界翻译成事件;

                                                                                        • Thread 把事件按线索归拢;

                                                                                        • Eval 做一次接单判断,Policy 给它尺子;

                                                                                        • Ticket 让工作有身份,Mandate 给它边界;

                                                                                        • Subscription 让上下文自动流动;

                                                                                        • Assignment 与 Executor 负责真正执行;

                                                                                        • Channel 把结果送回人群。

                                                                                        为什么这些概念不能合并,又或者是为什么不能简化?

                                                                                        假设简化了这里的结构,你说一句"顺便把日志降噪也做一下",系统可能就多出一张重复工单,或者改错一个地方。所以让工作持续关注且不越界需要同时保存两样东西——事件关系(让系统找到相关 Ticket)和工作约定(限定这项工作可以做什么)。

                                                                                        到这里,“一件事”有了形状:有来源、有身份、有边界、有执行者、有回话的渠道。但这些还是概念——落到机器上,它需要一套静态结构来承载:谁负责判断、谁负责执行、状态存在哪、出问题谁来看。

                                                                                        04

                                                                                        回到系统架构本身

                                                                                        为了达成前述目标,DSH 搭了一套架构。原文说得很清楚,五个模块支撑的是四个基础特征——连续、高效、主动、持久:

                                                                                        • 连续:在 IM、GitHub 等不同界面交互,感觉始终只有一个 Agent;

                                                                                        • 高效:响应快,同时能并行推进多个复杂任务;

                                                                                        • 主动:不等指令,持续观察环境事件并推进值得做的事;

                                                                                        • 持久:始终在线、接入真实环境,长期运行中能自愈。

                                                                                        四个特征与五个模块的对应关系是这样的:

                                                                                        这些模块听起来新,但追到根上,都是传统分布式系统的设计理念,这半年业界也或多或少都在往这个方向落地。

                                                                                         4.1 调度与执行分离

                                                                                        DSH的文章里面提到了双层架构,引入了Router和Worker层,听起来像是分工,但这里的本质实现延用的是一个更加本质的角色划分:控制面与数据面。

                                                                                        • Router在整个系统中充当控制面:判断一件事值不值得做、该交给谁、做到什么程度算完成。 它不执行,只决策。

                                                                                        • Worker层在整个系统中充当数据面:拿到任务就执行,专注把一个任务交付。

                                                                                         4.2 计算和状态分离:Agent as a Service

                                                                                        Worker 这个词不足以描述它的性质。更准确的说法是 Agent as a Service:它不是常驻的 Agent 实例,而是一个可调度、可替换的执行服务。这个差别,决定了架构能不能长——也就是能不能真的提升并行度。

                                                                                        网上很多人不理解:为什么非要"用户提问 → Router 分派 → Worker 执行",把每个环节隔离开、异步化,不是徒增复杂度?

                                                                                        先看常驻实例的思路(Agent in the Sandbox,代表是 WorkBuddy、Codex、Claude Code):一个实例绑着自己的记忆、工具集、性格。听起来很自然,也不需要分层和异步。但它有个死结——实例不可替代:它挂了,任务跟着挂;它慢了,任务跟着慢;它用的 Harness 过时了,任务只能跟着过时。

                                                                                        从服务化的角度看,状态与计算分离是必然的:把 Agent 的能力定义清楚,执行由谁来做变成可替换,把执行 Loop 做成无状态。今天用这个 Harness,明天换那个;今天跑在这台机器,明天跑在另一台;今天用这个模型,明天换更强的——对上层透明。

                                                                                        Worker 变成无状态服务之后,它就只是一个执行层。执行时的上下文、工具能力,由 Router 决策派发。于是 Agent 的并行度,在任务之间没有依赖的前提下,理论上等于单位时间内可并行的算力资源。

                                                                                         4.3 执行与环境分离:端云协同

                                                                                        把计算做成无状态、状态放进数据库,还有一个直接的推论:Agent Loop 不必再住在某一台机器上,它可以被调度到任何一台空闲的机器去跑——这就是“常驻云端”的意思。

                                                                                        而Agent Loop 和会话状态常驻云端之后,下一个问题就来了:怎么访问任务需要的执行环境?

                                                                                        模型干活所需的上下文,很大一部分要靠工具调用从代码仓库、本地文件、依赖服务里取。从这个意义上说,广义的上下文也包括执行环境本身。

                                                                                        常见做法是把代码拉进云端沙箱、重建环境、再跑。但真实工作环境往往复制不了:未提交的本地修改、私有凭据、本地配置文件、只在特定网络里可达的服务。

                                                                                        既然难以同步的是环境本身,那就不必让环境跟着计算一起上云。反过来做:让云端的 Agent 通过端侧一个轻量 daemon,按需接入真实环境。这个 daemon 不保存会话状态,只负责执行命令、返回结果。

                                                                                        这样 Sandbox 就从"Agent 的容器"变成了"Agent 的工具"——不是 Agent in the Box,而是 Sandbox as the Agent Tool。

                                                                                        一个 Agent 不再受限于单台机器,可以在不同执行设备之间切换,按任务需要选择环境、执行命令、获取上下文。用户的个人设备也成了 Agent 的一个工具:我要看用户机器上的某个文件,只需要通过端云之间的契约通道,像调 E2B Sandbox 一样调这台在线设备。

                                                                                        这个思路与 Anthropic 提的"脑手分离"是一致的:harness 保持无状态,会话日志放在 harness 之外,执行环境通过统一接口按需接入。区别在场景——那篇讲的是托管服务,这里首先要接入的是用户日常使用、可能间歇在线的个人机器,上面有未提交的修改和本地凭据。所以它天然支持 BYOM(Bring Your Own Machine),也能接云端托管机器。

                                                                                        把三条路线摆在一起,取舍就很清楚,对海量用户在用的 Agent 系统来说,既想抬高智能上限,又想压低使用成本,把 Agent 做进端侧 OS、端云结合,是一个折中解。

                                                                                         4.4 事件驱动:从 Trigger 到订阅直通

                                                                                        单会话时代,输入是用户敲的那句话。长程时代,主要输入变成了环境里发生的事:群里有人说话、CI 跑完了、有人提了 PR、监控报警了。人是其中一个来源,不再是唯一来源。

                                                                                        这个转变带来三个工程问题:怎么从海量事件里拿到事件;怎么筛出值得处理的、并把它定义成"一件事";以及拿到事件之后,往模型窗口里塞什么。

                                                                                        DSH 的解法,是把群聊消息、邮件、日程提醒、代码评审评论、CI 结果这类环境事件统称为 Trigger,由 Trigger 统一投喂。

                                                                                        拿到事件先过滤。前面说过 Fast Path 与 Slow Path 两级判断,这里不再展开。

                                                                                        过滤之后,消息要找到它该影响的任务。但如果每条消息都让 Router 重新判断一次,Router 自己就成了瓶颈。

                                                                                        于是 DSH 引入订阅直通:同一个 IM 话题、同一个工作区、同一个 PR 下的消息,构成一条 Thread。Router可以与订阅过的Thread建立直接关系,由程序直接送到 Worker 手上,不再经过 Router,只有尚未被订阅的新消息,才需要 Router 判断和分派。

                                                                                        订阅是多对多的:一个 Worker 可以订阅多条 Thread,一条 Thread 也可以被多个 Worker 订阅。这套订阅关系和消息系统的发布订阅思想类似:先确定归属、建立订阅,后续按已有关系投递,不必每条都重新判断。

                                                                                        回到订阅的前提,依然是前面的上下文边界——把一个工作上下文用有边界的 Context 隔离起来。在 DSH 里,这个边界我理解为 Thread。

                                                                                         4.5 面向人的交互:全双工、多信道

                                                                                        架构解决了"活怎么派下去",还剩"人怎么和它说话"。这里有两个问题:后台耗时操作会不会堵住前台对话;以及在不同信道里,它该用什么方式说话。

                                                                                        全双工: 经典 ReAct Loop 里,模型发起一次同步的 run() 工具调用后,循环就阻塞了,直到工具执行完、结果返回,期间会话无法响应任何新输入。要消除这个阻塞,得把对话从"一问一答"的半双工,变成全双工。

                                                                                        DSH 的做法是把耗时的命令与子任务调用改成异步的 start() 和 stop():模型调用 start() 后立即收到已启动的返回,循环不再等这个工具;后台执行完成后,系统再把最终结果作为一条新事件投递进会话。同时,模型也可以按需调用 stop(),主动终止跑得太久的后台命令

                                                                                        前台响应与后台执行就此解耦:Agent 在后台跑长任务的同时,仍能接人的输入;新输入在当前推理步结束时就被处理,不必等后台工具收尾。

                                                                                        多信道:双层架构已经解决了一部分问题——冗长的推理过程和密集的工具调用被隔离在 Worker 内部,由 Router 统一对外。但不同信道的带宽和习惯不一样,输出方式得跟着变:把面向单人终端的输出直接搬进群聊,很容易造成信息过载。

                                                                                        DSH做了不同信道输出的不同策略,且原文提到一条很实在的硬性规定:IM 场景单次回复不超过 100 词。这类规则看似琐碎,但它决定了 Agent 在群里的存在感是"同事"还是"噪音"。

                                                                                        云端异步: 把异步执行搬到云端、服务海量用户的 Agent 任务时,还有一个问题:异步结果怎么交回会话?RPC 回调、原地轮询都不是好答案。从系统角度看,很自然会想到消息系统。

                                                                                        消息系统在这里的价值有四条:

                                                                                        • 时间解耦:发起方不必等结果,结果以消息形式回来。

                                                                                        • 位置解耦:模型池和工具端可以在不同机器、不同网络——中间隔着一条通道,不是一个调用栈。

                                                                                        • 可靠投递:进程崩了消息还在,重启能续上。内存回调和 RPC 都做不到。

                                                                                        • 可控消费:消费方可以"暂时不接",消息留在系统里等下一次。

                                                                                        消息系统本身很成熟,但 Agent 时代需要对它做改造。原因在于:传统异步消费假设"一个队列里的消息同质可互换",所以一个 Topic 下挂一组消费者,谁空了谁拿。但 Agent 任务不同质——一条消息可能要跑二十分钟,一条慢消息就能拖住整个队列。

                                                                                        这个问题 DSH 原文没有给答案,或许内部不是使用消息系统来解耦实现,但针对消息系统上业界在Ai时代也做了很多新尝试,比如RocketMQ 的 LiteTopic。

                                                                                         4.6 看门狗Watchdog

                                                                                        长期在线的分布式系统,很难只靠主系统内部的逻辑保证长期可靠,通常要在主系统之外放一个独立的外部控制回路,如k8s的控制循环。

                                                                                        但Agent 场景的难点在于:很多故障不是进程崩了,而是任务本身没进展。 传统的存活探测发现不了"模型在原地打转",也发现不了"方向已经偏了"。

                                                                                        DSH 的做法是在主系统之外配一个独立的 Watchdog Session,用定时消息驱动它巡检:

                                                                                        • 系统本身:处理接口报错、状态恢复失败之类的系统故障。

                                                                                        • 业务本身:由模型判断每个任务有没有实质进展、方向有没有偏离整体目标。

                                                                                        发现异常就介入修复,遇到外部偶发故障,就持续复查,直到恢复。

                                                                                        05

                                                                                        让Super-agent更加Super的一点设想

                                                                                        回到我自己,DSH 把"系统内部怎么运转"这一半回答得相当完整,但还有三个idea在系统边界之外——或许他们能让一个 Agent 更加 Super。

                                                                                        一句话概括:Agent 缺三样东西——身份、感知、界面。身份决定它能进哪些系统,感知决定它什么时候该动,界面决定人怎么看到和改动它的结果。

                                                                                         5.1 身份:一个有身份的 Agent

                                                                                        现在 Agent 都是借你的身份干活:用你的 cookie 提 PR,用你的 token 发消息。但身份不是自己给的,是平台发的。

                                                                                        GitHub 得愿意给它开 machine account,企业微信得愿意发它一个机器人身份,OA、日历、支付、审批——每一个系统都得在权限体系里给它留一个位置。

                                                                                        过去一年,我的 Coding 工具从 Claude Code、Codex 换到 CodeBuddy,再到 WorkBuddy。就 Harness 而言,绝大多数情况下交付质量差不多;但 WorkBuddy 的 Agent 身份带来了极致的便捷——我可以把所有数据资产 All in One Buddy。

                                                                                        所以我把"生态"理解成一句话:生态不是功能有多少,是有多少系统愿意认这个身份。

                                                                                        这也解释了为什么模型再强也换不来生态。模型会趋同,今天你强 3%,下个月可能就抹平了;而算力会变便宜;Harness 会开源。这些都会贬值。

                                                                                        但"这个 Agent 能进哪些系统、以什么身份进、被谁信任",不会让自己变便宜。

                                                                                        这就是我说"最后值钱的是身份、身份背后是生态"的原因:一个 Agent 的能力上限,是它能拿到多少身份;它的价值,是这些身份连起来的那张网。

                                                                                         5.2 感知:Trigger 应该感知到更多

                                                                                        DSH 的 Super-agent 案例里,事件源仍然是传统的那几类:GitHub、IM、问答。这些都能用 Webhook 实现,能力也现成。

                                                                                        但有个问题被忽略了:现在的 Trigger,主要是定时器和消息。

                                                                                        定时器好理解,cron 到点就跑。消息事件也好理解:有人说话、有条评论、有个 PR。这两类东西有个共同点——它们都是"发生了什么",需要有人主动发出来。

                                                                                        但真实业务里,大量关键变化不是消息,是状态。

                                                                                        你早上打开电脑,没人会发一条消息通知 Agent。你今天的步数、心率、睡眠,也不会有人主动推送。滴滴司机接单了、换路线了、快到了——这些是订单状态的迁移,不是聊天消息。会议结束了、日程变了、邮件到了,同样如此。

                                                                                        这些变化的共同点是:它们都是状态,不是消息。没有人会为"司机的状态变了"发一条推送给你,但这个状态恰恰决定了 Agent 该不该动,能不能做得更加符合理想形态中的智能。

                                                                                        所以我认为,Trigger 的本质不是事件接入,是感知力。

                                                                                        在连接器的世界里,一个连接器只做到"能被调用"是不够的——那是"我什么时候问你,你什么时候答"。真正需要的是反过来:它变了,它主动告诉我。

                                                                                        也就是说,连接器不只是工具,还得是传感器。它要能订阅:订阅状态、订阅变化、订阅边界条件。

                                                                                        感知力上去了,主动服务才成立。否则所谓"主动",不过是定时轮询一遍所有接口——那既不是感知,也撑不住系统规模。

                                                                                         5.3 界面:Agent 能自己长出超级 App

                                                                                        过去软件的形态是:人打开界面,操作功能。Agent 是后加的,要么浮在旁边,要么藏在对话框里。

                                                                                        但如果 Agent 真的成为主体,界面这件事就得翻过来:不是人操作软件,而是 Agent 编排能力,界面是人看它编排结果的窗口。

                                                                                        这里引用Minimax的观点:https://agent.minimax.cn/docs/miniapp/overview

                                                                                        这要求 Agent 手里得有第三样东西。第一样是工具调用——一次性把事做完;第二样是工作台—— 能持续存状态、能被反复进出;第三样是界面——人能看到、能改、能确认。

                                                                                        现在的 Agent 大多只有第一样。生成一个 HTML 页面,看起来像有界面,但它是死的: 数据停在生成那一刻,要更新还得回聊天里重新交代,改完也留不下来。

                                                                                        一个真正的“应用”,至少要补三样:

                                                                                        • 持续运行。有后端在跑,能持续取数、保存结果,重启之后数据还在。

                                                                                        • 双向调用。Agent 能调它的工具,它也能请 Agent 在后台干活。

                                                                                        • 边界明确。能调什么写在声明里,权限由宿主把关,而不是靠提示词约束。

                                                                                        所以“超级 APP”的超级,我认为不在功能多,也不在入口统一,而在于—— Agent 能不能自己长出它需要的那个界面。

                                                                                        一个只能在你现成软件里点来点去的 Agent,能力上限就是你那些软件; 一个能给自己造工作台的 Agent,上限才是它自己的判断力。

                                                                                         5.4 结语

                                                                                        写到这里,我想回到贯穿全文的那个幻想:贾维斯。

                                                                                        很多人记得它聪明、有性格、会调侃。但我不这么看。贾维斯真正厉害的地方,是它能调动斯塔克工业的所有系统——实验室的门、装甲库的权限、卫星的视野、财务的账。它不只是个聪明的助手,它是那个世界的一个身份。

                                                                                        把这个观察套回 Agent,会得到一个有点残酷的结论:单个 Agent 的能力上限,很快会被拉平。今天某家模型多会写代码,明天别家就追上了;今天某个 Harness 有巧妙设计,明天开源社区就有了。

                                                                                        但"它能进哪些系统、以什么身份进、被谁信任",不会自己变便宜。这也是为什么大厂都在抢入口、抢协议、抢身份体系:模型这层迟早变成水电,身份和生态这层才是价值所在。

                                                                                        所以把前面几节收拢成一句话:真正的 Super,不在于它有多聪明,而在于它能连上多少东西。 只有打通生态、连接万物,才谈得上 Super。一个只能在自己一亩三分地里干活的 Agent,做得再精致,也只是个很强的工具,不是理想形态的贾维斯。

                                                                                        回到开头那个"3 到 5 个活跃 Session"。解法分两半:一半在架构——把记忆、调度、审批、恢复等搬进系统,解放人的注意力;另一半在生态——让这个系统拿到足够多的身份,替你走进足够多的现场。

                                                                                        前半部分,DSH 这篇设计探索给了很好的答案。后半部分,也许才刚刚开始。

                                                                                        -End-

                                                                                        原创作者|陈焕新

                                                                                        感谢你读到这里,不如关注一下?👇

                                                                                        扫码领取腾讯云开发者专属服务器代金券!

                                                                                        图片

                                                                                        跳转微信打开

                                                                                        为什么AI会“选择性失忆”:搞懂Transformer架构

                                                                                        2026年11月4日 08:45

                                                                                        原创 朱进 2026-11-04 08:45 新加坡

                                                                                        关注腾讯云开发者,一手技术干货提前解锁👇

                                                                                        开发者公众号专属群聊

                                                                                        扫码加入获取更多一手教程、科技前沿报告

                                                                                        当你跟 AI 聊了 50 轮,它却忘了第 1 轮你说过的话;可你问它三年前训练数据里的冷知识,它倒背如流。这种"选择性失忆"到底是 bug 还是特性?答案藏在 Transformer 的架构基因里。本文用精确图解 + 一个失忆案例,把机制讲透。

                                                                                        上图就是本文的完整隐喻:一个 AI 机器人面对满墙便签(你说过的话),一束聚光灯(注意力)只照亮了几张——其余的褪色、模糊、消散。聚光灯照到哪里,它就"记得"什么;照不到的,就被遗忘了。这不是 bug,是聚焦的代价。

                                                                                        01

                                                                                        失忆现场与双轨定位

                                                                                         1.1 一个失忆现场

                                                                                        你跟 AI 说了 50 轮话,第 1 轮提到"我家猫叫团子",第 50 轮问它"我的猫叫啥"。它回你:

                                                                                        “喵?您还没告诉过我您养猫呢。”

                                                                                        它不是撒谎,也不是记忆力差——它在做选择:哪些信息值得占用注意力,哪些该被"挤下台"。做出这个选择的机制,就是 Transformer 的灵魂:自注意力(Self-Attention)。

                                                                                        但在拆解机制之前,先看清一个反直觉的真相:AI 的"失忆"其实是两套完全不同的系统在起作用。

                                                                                         1.2 先分清:AI 的"双轨记忆系统"

                                                                                        很多人以为 AI 只有一种记忆,其实有两条轨道,遗忘方式天差地别:

                                                                                        左边这条轨道刻在参数里:训练时写死的知识,像百科全书印好了就不再变——所以 AI 永远记得"地球绕太阳转"。

                                                                                        右边这条轨道叫工作记忆:每次对话时临时存在"上下文窗口"里的内容,像一张用完就丢的便签——你 10 分钟前说的"我家猫叫团子",就存在这里。

                                                                                        关键结论:"选择性失忆"只发生在右边这条轨道上——注意力稀释 + 窗口截断,与左边那本"百科全书"无关。这就是为什么 AI 忘得了你的话,却忘不了牛顿定律。

                                                                                        搞清楚病因在哪条轨道后,先别急着钻进公式——我们退后一步,看看 Transformer 的全景架构,排查一下到底哪些零件和失忆有关,哪些是"清白"的。

                                                                                        02

                                                                                        先见森林:全景排查

                                                                                        理解 Transformer 失忆,不能只盯着注意力——先看清整条流水线,才能锁定"病灶"位置:

                                                                                        一条流水线读下来:

                                                                                        • Token 化 + Embedding:文字切块、变向量——AI 的"通用语言"

                                                                                        • 位置编码:给每个词发"座位号"。自注意力天生"人脸盲"(它把输入当一袋子词),没有座位号,"猫追狗"和"狗追猫"在它眼里就是同一句话

                                                                                        • 自注意力(金色核心):全场环顾,决定"我该听谁的话"——选择性记忆在这里发生

                                                                                        • 前馈网络 FFN:对每个词独立"深度思考"。有趣的事实:参数的大部分和知识的主要存储地都在 FFN 里,注意力层负责"调取",FFN 负责"加工"

                                                                                        • × N 层堆叠:上述模块重复几十层,逐层抽象——底层抓语法,高层抓语义

                                                                                         2.1 残差连接:信息的高速通道

                                                                                        每层都给信息留一条"高速直通道"(输入直接加到输出),防止信息在深层网络中迷路。注意:它解决的是梯度消失,管不住注意力层里的权重稀释——我们在下一章会看到,残差救不了"失忆"。

                                                                                         2.2 LayerNorm:稳定每一层的"血压"

                                                                                        每层输出做归一化(减均值、除标准差),防止数值越算越大或越算越小。可以理解为给网络"稳血压"——不直接影响记忆,但缺了它,深层 Transformer 根本训不动。

                                                                                        排查结论:残差连接和 LayerNorm 是"清白零件"——它们保障训练稳定,但不制造失忆。真正的病灶是金色核心:自注意力。下一章,我们把它拆开看。

                                                                                        03

                                                                                        自注意力:软遗忘发动机

                                                                                         3.1 从一个句子到 QKV

                                                                                        “猫 追 球”

                                                                                        三个词,每个词处理时都要回答一个问题:"我该听谁的话?" 猫需要知道谁在追它,追需要知道追的是什么,球需要知道谁在追它。这个"听谁的"的决策,就是通过 Q、K、V 三步计算完成的。

                                                                                        很多教程用"图书馆借书"比喻 QKV,但这个比喻容易让人以为 Q、K、V 是三种不同的东西。真相是:每个词的输入向量,经过三个不同的权重矩阵变换,得到三份"身份证"。

                                                                                        如上图,同一个词"猫",乘以 Wq 得到它的 Query(我要找什么),乘以 Wk 得到它的 Key(我有什么标签),乘以 Wv 得到它的 Value(我的实际内容)。三个矩阵都从同一段文字生成,只是"视角"不同。

                                                                                         3.2 三步计算,与软遗忘的诞生

                                                                                        Step 1:Q × K^T = 打分矩阵

                                                                                        每个词的 Query 去和所有词的 Key 做点积,算出"相关度分数"。上图中圆点越大,分数越高——"猫"和自己最相关,"追"和"球"也高度相关(动宾关系)。

                                                                                        为什么用点积?因为两个向量方向越一致,点积越大——方向一致 = 语义相关。这不是人为规定,是向量空间的数学性质。

                                                                                        Step 2:softmax = 分蛋糕

                                                                                        把分数变成"百分比蛋糕"——每行加起来必须等于 100%。这一步是零和博弈的起点:有人份额大,就有人份额小。

                                                                                        为什么要除以 √dk?点积的结果会随向量维度 dk 增大而变大,大到 softmax 的梯度几乎为零(函数进入饱和区)。除以 √dk 把数值拉回合理范围,让梯度能正常流动。这不是“调参”,是数学上的必需。

                                                                                        软遗忘就诞生在 Step 2。对话越长,softmax 要分的蛋糕份数越多。一个 1000 轮的对话里,早期词分到的份额被稀释到 0.001 以下——乘以 V 后几乎不被采纳。信息还在窗口里,但注意力权重已经把它淹没。就像开头那张图里褪色的便签——纸还在,字已经看不清了。

                                                                                        上面是理论推导,下面看真实分布——

                                                                                        这是"小猫追毛线球因为它很无聊"的注意力分布。可以看到两件事:

                                                                                        • "它"那一行,"小猫"格子最深——AI 正确猜中指代关系,靠的就是高权重锁定

                                                                                        • 大面积浅色格子——AI"看见"了这些词,但基本没理睬

                                                                                        一句话记住:遗忘不是删除,而是注意力权重把信息淹没。 残差连接给的是梯度通道,管不了注意力权重的稀释——正如第二章所预判,残差救不了"失忆"。

                                                                                        继续第三步——

                                                                                        Step 3:权重 × V = 输出

                                                                                        按百分比混合所有词的 Value,生成每个词的新表示。以"猫"为例:新表示 = 0.8×V(猫) + 0.1×V(追) + 0.1×V(球)——它主要保留了自己的信息,微微吸收了"追"和"球"的语义。

                                                                                        三步串起来就是一句话:Q 决定"问什么",K 决定"匹配什么",softmax 决定"信多少",V 决定"拿到什么"。

                                                                                         3.3 多头注意力:多个"专科医生"并行会诊

                                                                                        自注意力有一个问题:一个头只能学一种关系模式。如果"猫→追"的语法关系和"猫→球"的语义关系冲突,单头注意力只能二选一。

                                                                                        解决方案是多头注意力:把 Q/K/V 拆成多组(GPT-3 用 96 个头),每组独立做注意力,最后拼接。每个头可以专注于不同的关系模式:

                                                                                        如上图,同一句"猫追球"进入三个头,各自看到不同的关系:

                                                                                        • 头 1(语法):锁定"猫→追"的主谓关系——谁在追?

                                                                                        • 头 2(语义):锁定"猫↔球"的名词聚类——哪些词是一类?

                                                                                        • 头 3(位置):锁定相邻关系——谁挨着谁?

                                                                                        三个头的输出拼接后,经过 WO 线性变换,融合成统一表示。不是一个大脑袋看所有关系,而是多个专科医生各看一面,最后会诊。

                                                                                        实证研究发现,Transformer 的不同注意力头确实会自发学到不同模式:有的盯语法、有的盯共指消解(“它”指代谁)、有的盯位置远近。这种“自发分工”是多头机制的核心价值——不是人为指定,是训练过程中自然涌现的。

                                                                                        软遗忘讲完了——信息还在,但已经不重要了。但还有一种更彻底的遗忘:信息压根没进场。下一章看"硬遗忘"。

                                                                                        04

                                                                                        硬遗忘:窗口与 O(n²)

                                                                                         4.1 窗口截断:比淹没更彻底

                                                                                        Softmax 稀释好歹是"看见了但没重视",还有一种更彻底的遗忘——上下文窗口截断。

                                                                                        Transformer 能"看见"的 token 数量是固定的(早期 4K,现在主流 128K,最长约 1M)。超出窗口的内容,不是被遗忘,而是从未参与计算——物理上不存在。

                                                                                        回到开头的案例:你第 1 轮说"我家猫叫团子",聊到第 50 轮问"我的猫叫啥",AI 答你"您还没告诉过我您养猫呢"。它不是撒谎——第 1 轮的内容压根没进入这一次的计算。

                                                                                         4.2 为什么窗口不能无限大?O(n²) 的暴政

                                                                                        注意力的计算量随序列长度平方增长:每个词都要和所有其他词两两配对(Q × K^T 矩阵)。

                                                                                        为什么是平方而不是线性?因为 RNN 的计算量是 O(n)——每个词只跟前一个词交互;Transformer 让所有词两两交互,计算量跳到 O(n²)。并行赢了速度,但输给了规模——这就是窗口不能无限大的根源,也是后续一切优化的起点。

                                                                                        工程师的一切优化(Flash Attention、KV Cache、RAG),本质上都是在和这个 O(n²) 博弈。

                                                                                        05

                                                                                        两次取舍:一眼看全场,与不偷看未来

                                                                                         5.1 串行 vs 并行:一眼看全场

                                                                                        如上图,RNN 处理"猫追球"必须串行:先读"猫"算出隐状态,传给"追",再传给"球"——每个词必须等前一个词算完。这带来两个致命问题:

                                                                                        • 训练慢:无法并行利用 GPU,序列越长越慢

                                                                                        • 长距离衰减:信息从第 1 个词传到第 100 个词,要经过 99 次传递,每次乘以一个权重,信号不断衰减——就像传话游戏,传到最后面目全非

                                                                                        Transformer 的革命性在于:所有词同时入场,一步内互相看见。"猫"可以直接和"球"做点积,不需要经过"追"中转。这不仅让训练可以大规模并行(GPU 友好),还让任意距离的两个词之间没有信号衰减。

                                                                                        这就是论文标题 Attention Is All You Need 的底气——砍掉 RNN 的串行循环,只用注意力实现全局直连,既快又准。

                                                                                        代价就是上一章算过的那笔 O(n²) 账单——并行赢了速度,但窗口不能无限大。这是一次取舍:用计算复杂度换并行能力和零衰减。

                                                                                         5.2 因果掩码:不偷看未来

                                                                                        第二个取舍关于生成。到目前为止我们讲的都是"理解"场景——所有词都已给出,注意力让它们互相看。但 GPT 的核心任务是生成:一个词一个词往外蹦。这就带来一个问题——生成第 3 个词时,第 4、5、6 个词还不存在,AI 不能"偷看"未来。

                                                                                        解决方案是因果掩码(Causal Mask):在注意力矩阵的上三角(未来位置)填上 −∞,softmax 后变成 0,等价于"假装那些位置不存在"。

                                                                                        如上图,生成"球"时,注意力只能看见"猫"和"追"——上三角的格子被屏蔽(打叉),不参与计算。

                                                                                        这个掩码机制区分了两种 Transformer 架构:

                                                                                        • Encoder(编码器,如 BERT):双向注意力,每个词可看全部词。适合理解任务——分类、填空、相似度判断

                                                                                        • Decoder(解码器,如 GPT):因果掩码注意力,只能看 ≤ 自己的位置。适合生成任务——写文章、写代码、对话

                                                                                        GPT 系列只用 Decoder——所以它天生只能"从左往右逐词生成",这也意味着它生成第 N 个词时,无法回头修改前 N-1 个词。这是第二次取舍:用单向性换取自回归生成能力。

                                                                                        屏蔽的数学本质:设被屏蔽位置的分数为 −∞,softmax 中 e^{−∞} = 0,权重归零。一行物理直觉:你不能让未来的信息“泄漏”到当前步,否则训练时模型会作弊(直接抄答案),推理时则无答案可抄,行为崩坏。

                                                                                        06

                                                                                        失忆治疗手册

                                                                                        开药之前,先看诊断书——两种遗忘的完整对照:

                                                                                        选择性失忆 = 工作记忆轨道的宿命:软遗忘(softmax 稀释)+ 硬遗忘(窗口截断),二者叠加,构成了 AI "忘事"的完整图景。

                                                                                        病因明确(softmax 稀释 + 窗口截断 + O(n²)),药方对症:

                                                                                         6.1 药方一:扩窗口(治硬遗忘)

                                                                                        从 GPT-1 的 512 到如今百万级 tokens,本子越扩越大。但 O(n²) 在那里,扩窗口 = 烧钱,成本随长度平方增长。

                                                                                         6.2 药方二:KV Cache(省算力)

                                                                                        已算过的 Key/Value 缓存复用,不重复计算。不解决遗忘,但让大窗口在工程上可行。

                                                                                         6.3 药方三:RAG(外包记忆)

                                                                                        不指望模型"记住",而是每次回答前先去外部知识库检索相关资料,塞进上下文窗口。相当于把"长期记忆"外包给数据库,AI 只需要"这次看得见"。这是当前企业级 AI 应用(包括 KM 里的智能问答)的主流方案。

                                                                                         6.4 药方四:注意力变体(改游戏规则)

                                                                                        Flash Attention(同样的数学,更聪明的算法规避内存瓶颈)、Sparse / Linear Attention(打破 O(n²),只算值得算的部分)。长期看,这是最根本的路线。

                                                                                        07

                                                                                        写在最后:失忆是特性,不是缺陷

                                                                                        回到开头的问题:AI 的"选择性失忆"是 bug 吗?

                                                                                        现在你可以回答了:它是注意力机制的必然代价。softmax 的零和博弈让 AI 能在无穷信息中聚焦最相关的部分——如果每个词都平均关注所有词,它反而什么都学不会。遗忘,是聚焦的价格。

                                                                                        Transformer 的记忆哲学:参数记忆负责“我知道什么”,注意力记忆负责“我现在关心什么”。前者给你知识,后者给你语境;而“失忆”,只是后者为了让你清醒而付出的代价。

                                                                                        理解了这一层,你就理解了 RAG、长上下文、KV Cache、Flash Attention 这些热门技术到底在解决什么问题——它们都是在这条"注意力经济"的约束下,帮 AI 把有限记忆花在刀刃上的不同策略。

                                                                                        -End-

                                                                                        原创作者|朱进

                                                                                        感谢你读到这里,不如关注一下?👇

                                                                                        扫码领取腾讯云开发者专属服务器代金券!

                                                                                        图片

                                                                                        跳转微信打开

                                                                                        一文搞懂MCP开发

                                                                                        2026年11月3日 08:45

                                                                                        原创 陈畅 2026-11-03 08:45 广东

                                                                                        关注腾讯云开发者,一手技术干货提前解锁👇

                                                                                        开发者公众号专属群聊

                                                                                        扫码加入获取更多一手教程、科技前沿报告

                                                                                        MCP(Model Context Protocol)是 Anthropic 于 2024 年底开源的协议,定义了 AI 应用发现和调用外部能力的标准方式。本文从"为什么需要 MCP"出发,逐步讲解协议的核心概念、安全模型与传输机制。

                                                                                        基于 MCP 规范 2026-07-28 和 TypeScript SDK v2(@modelcontextprotocol/server)。

                                                                                        01

                                                                                        什么是 MCP

                                                                                         1.1 什么是 MCP

                                                                                        在 MCP 出现之前,AI 应用对接外部系统时,每个组合都需要编写一套专用的胶水代码:对接 Notion 的 API、将响应转换为模型可消费的格式、再接入 Cursor 的工具系统。更换 Host(Claude、VS Code)或数据源(Sentry、TAPD)后,整套集成工作需要重新实现。3 个 AI 应用 × 3 个数据源 = 9 套集成。

                                                                                        没有 MCP:每个组合各写一套

                                                                                        MCP 的方案是在中间引入一层标准协议,将"如何建立连接、如何发现能力、如何调用工具"统一约定:

                                                                                        1. Server 侧:数据源方按协议暴露能力——声明工具(名称、描述、参数 schema)、资源与提示模板。底层仍然调用自身的 REST API,但对 Host 仅暴露统一的 tools/list、tools/call 等接口。

                                                                                        2. Host 侧:AI 应用实现一次 Client——具备发现工具、将 schema 传递给模型、按协议发起调用、将结果回注对话上下文的能力。此后对接任何 MCP Server 均可复用同一条路径。

                                                                                        3. 模型侧:无需感知底层是 Notion 还是 Sentry,仅依据工具描述与参数 schema 决定调用时机和传参内容。

                                                                                        由此 M×N 降为 M+N:每个数据源实现一个 Server,每个 AI 应用完成一次 Client 适配。Notion 发布官方 MCP Server 后,Cursor、Claude、VS Code 均可直接接入,无需各自重复实现 Notion 集成。

                                                                                        有 MCP:协议居中,两侧各实现一次

                                                                                         1.2 MCP vs Function Calling

                                                                                        一个常见的问题是:"MCP 和 OpenAI 的 Function Calling 有什么区别?"两者并非替代关系,而是分属不同抽象层次:

                                                                                        概括而言:Function Calling 定义了"模型如何表达调用意图",MCP 定义了"调用意图如何标准化地到达外部系统"。

                                                                                        两者的差异可直接体现在代码层面。以"搜索文档"工具为例:

                                                                                        Function Calling(无 MCP):工具 schema 与执行逻辑均由应用侧维护。

                                                                                          const tools = [{
                                                                                            name: 'search_docs',
                                                                                            description: '按关键词搜索文档',
                                                                                            parameters: { type: 'object', properties: { query: { type: 'string' } } }
                                                                                          }];
                                                                                          const res = await openai.chat.completions.create({ messages, tools });
                                                                                          // 模型返回 function_call 后,执行逻辑仍需由业务侧实现:
                                                                                          const result = await searchDocs(JSON.parse(res.function_call.arguments));

                                                                                          更换数据源时,schema 与执行代码均需重复实现。

                                                                                          MCP:schema 与执行逻辑封装于 Server 内,应用侧仅需一行配置。

                                                                                            { "mcpServers": { "docs": { "url": "https://mcp.docs.example.com" } } }

                                                                                            实际运行中两者是串联的——Host 将 MCP Server 的 tools/list 转换为 Function Calling 格式交给模型,模型选定工具后,Host 再通过 MCP 协议发起调用:

                                                                                            对应上一节的 M×N 问题:Function Calling 标准化了"模型 → 工具"这一环节,但"工具 → 外部系统"的后续环节仍需各应用独立实现——MCP 标准化的正是后者。

                                                                                             1.3 Agent / Skill / MCP / CLI

                                                                                            MCP 并非独立使用,它与 Agent、Skill、CLI 分属不同层次。以类比说明:Agent 相当于项目经理,负责分解任务与决策调度;Skill 相当于操作手册,规定"这件事按什么步骤执行";MCP 相当于外部服务的标准接口,类似于企业内部的 API 网关;CLI 则是可直接调用的现有工具。

                                                                                            实际任务中它们常组合使用。以"按文档站规范检查一篇稿件并提交 PR"为例:

                                                                                            1. Agent 分解目标:查阅规范 → 检查内容 → 修复问题 → 提交 PR

                                                                                            2. Skill 提供检查清单:标题层级、代码块标注语言、术语首次出现使用全称

                                                                                            3. MCP 获取外部数据:从 iWiki 检索最新术语表、从 TAPD 查询关联需求编号

                                                                                            4. CLI 执行本机操作:pnpm lint 检查格式、gh pr create 提交 PR

                                                                                            选型原则:固定流程写入 Skill,动态数据通过 MCP 获取,本机操作交由 CLI 执行。

                                                                                             1.4 适用场景

                                                                                            需要明确一个前提:MCP 是面向 AI 应用的协议,而非面向终端用户的 API。它架设在已有的 API 或数据层之上,约定的是"模型如何发现和调用能力",并不替代业务中间层本身。

                                                                                            适合引入的场景:

                                                                                            • 多个 AI 应用需要共享同一套能力(Cursor + Claude + 自研产品)

                                                                                            • 底层已具备稳定的 API 或数据层

                                                                                            • 读写操作需要分级授权,关键操作需要审计

                                                                                            不适合引入的场景:

                                                                                            • 调用方不涉及模型参与(网页前端、脚本、定时任务)——此时直接调用 REST API 即可

                                                                                            • 仅有一个完全可控的 AI 应用,将工具定义硬编码即可满足需求

                                                                                            • 底层 REST API 尚未稳定——MCP 无法弥补底层业务能力的缺失

                                                                                            生态层面,主流服务商已普遍跟进,官方和社区的 Server 实现层出不穷,以下仅列举部分代表:

                                                                                            02

                                                                                            核心概念

                                                                                            以一次完整的工具调用串联所有概念:用户在 Cursor 中输入"搜索文档站里关于认证的内容",从这条指令出发,观察各层如何协作。以下是全流程时序总览,后续小节将逐一展开。

                                                                                             2.1 三个角色

                                                                                            指令首先到达 Host(Cursor),Host 内部为每个已配置的 MCP Server 维护一个 Client 实例,由 Client 负责与对应的 Server 通信。

                                                                                            Host 与 Server 不直接交互,中间始终经过 Client。一个 Host 可同时持有多个 Client(文档站、TAPD、iWiki 等),各连接彼此隔离。

                                                                                             2.2 两层架构

                                                                                            Client 与 Server 之间的通信分为两层:

                                                                                            • 数据层:基于 JSON-RPC 2.0,定义方法(tools/list、tools/call、resources/read、server/discover 等)及其请求 / 响应格式。

                                                                                            • 传输层:决定消息的传输方式——本地部署使用 stdio(Host 以子进程方式启动 Server),远程部署使用 Streamable HTTP。第 3 节将展开传输层细节。

                                                                                             2.3 能力协商

                                                                                            在发起任何工具调用之前,Client 首次连接时需先发送 server/discover 请求,获取 Server 的能力声明:

                                                                                              // 请求
                                                                                              {
                                                                                                "jsonrpc": "2.0",
                                                                                                "id": 0,
                                                                                                "method": "server/discover",
                                                                                                "params": {
                                                                                                  "_meta": {
                                                                                                    "protocolVersion": "2026-07-28",
                                                                                                    "clientInfo": { "name": "cursor", "version": "0.50" }
                                                                                                  }
                                                                                                }
                                                                                              }

                                                                                                // 响应
                                                                                                {
                                                                                                  "jsonrpc": "2.0",
                                                                                                  "id": 0,
                                                                                                  "result": {
                                                                                                    "protocolVersion": "2026-07-28",
                                                                                                    "serverInfo": { "name": "docs-assistant", "version": "1.0.0" },
                                                                                                    "capabilities": {
                                                                                                      "tools": {},
                                                                                                      "resources": { "subscribe": true },
                                                                                                      "prompts": {}
                                                                                                    }
                                                                                                  }
                                                                                                }

                                                                                                请求通过 _meta 声明 Client 期望的协议版本,响应中的 protocolVersion 即双方最终协商的版本——版本不匹配时 Server 返回 UnsupportedProtocolVersion 错误。capabilities 中声明的键即为 Server 支持的能力集:tools 表示支持工具调用,resources 表示支持资源读取,subscribe: true 表示 Server 支持资源变更的主动推送。Client 根据此响应确定可用的方法集合,避免向不支持对应能力的 Server 发送无效请求。

                                                                                                 2.4 三种原语

                                                                                                能力协商完成后,Host 已获知 Server 支持的能力集。MCP 将 Server 的能力抽象为三种原语,核心区分在于控制权归属:

                                                                                                原语

                                                                                                控制方

                                                                                                在此场景中

                                                                                                其他典型用途

                                                                                                Tools

                                                                                                模型决定调用

                                                                                                模型判断需要搜索,自主调用 search-docs

                                                                                                create-issue

                                                                                                、send-message

                                                                                                Resources

                                                                                                应用层注入上下文

                                                                                                Cursor 将写作规范注入对话,供模型参考

                                                                                                数据库 schema、API 文档

                                                                                                Prompts

                                                                                                用户主动选择

                                                                                                用户选择"审校文档"模板,预组装一组消息

                                                                                                "写发布说明"、"分析错误日志"

                                                                                                Tools

                                                                                                Tools 是实际开发中使用频率最高的原语。与传统 API 不同,MCP 的调用方是概率模型——模型依据工具的 description 决定调用时机与传参内容,因此工具描述的质量直接影响调用准确率。

                                                                                                模型决定调用 search-docs 后,Client 向 Server 发出如下 JSON-RPC 请求:

                                                                                                  {
                                                                                                    "jsonrpc": "2.0",
                                                                                                    "id": 1,
                                                                                                    "method": "tools/call",
                                                                                                    "params": {
                                                                                                      "name": "search-docs",
                                                                                                      "arguments": { "query": "认证", "limit": 5 },
                                                                                                      "_meta": {
                                                                                                        "protocolVersion": "2026-07-28",
                                                                                                        "clientInfo": { "name": "cursor", "version": "0.50" }
                                                                                                      }
                                                                                                    }
                                                                                                  }

                                                                                                  Server 处理完成后返回响应:

                                                                                                    {
                                                                                                      "jsonrpc": "2.0",
                                                                                                      "id": 1,
                                                                                                      "result": {
                                                                                                        "content": [
                                                                                                          { "type": "text", "text": "找到 1 篇文档:\n\n- **身份认证** (id: authentication)" }
                                                                                                        ]
                                                                                                      }
                                                                                                    }

                                                                                                    注意 _meta 字段:协议要求所有客户端请求都必须携带它(server/discover、tools/call、resources/read、prompts/get 等无一例外,缺失会收到 -32602 错误),其中声明协议版本与客户端身份信息。自 2026-07-28 规范起,MCP 采用无状态协议设计——服务端不维护连接上下文,不依赖前序请求的状态。这使得远程 Server 天然具备水平扩展能力;但相应地,跨请求的业务状态(如购物车、工作流 ID)需由 Client 在每次请求中显式传递。

                                                                                                    Resources

                                                                                                    Resources 是 Server 向 Host 暴露的只读数据。与 Tools 的核心区别在于:Tools 是模型主动调用的"动作",Resources 是应用层主动拉取的"上下文"——由 Host 决定何时读取并注入对话,模型不直接参与控制。

                                                                                                    Client 通过 resources/list 发现可用资源,再通过 resources/read 读取内容:

                                                                                                      // 请求
                                                                                                      {
                                                                                                        "jsonrpc": "2.0",
                                                                                                        "id": 2,
                                                                                                        "method": "resources/read",
                                                                                                        "params": {
                                                                                                          "uri": "docs://style-guide",
                                                                                                          "_meta": {
                                                                                                            "protocolVersion": "2026-07-28",
                                                                                                            "clientInfo": { "name": "cursor", "version": "0.50" }
                                                                                                          }
                                                                                                        }
                                                                                                      }

                                                                                                        // 响应
                                                                                                        {
                                                                                                          "jsonrpc": "2.0", "id": 2,
                                                                                                          "result": {
                                                                                                            "contents": [
                                                                                                              {
                                                                                                                "uri": "docs://style-guide",
                                                                                                                "mimeType": "text/markdown",
                                                                                                                "text": "# 写作规范\n\n- 标题不超过三级\n- 术语首次出现用全称..."
                                                                                                              }
                                                                                                            ]
                                                                                                          }
                                                                                                        }

                                                                                                        若 Server 在能力协商中声明了 resources.subscribe: true,Client 可订阅指定资源的变更通知。当资源更新时,Server 主动推送 notifications/resources/updated,Client 重新拉取最新内容,无需轮询。

                                                                                                        Prompts

                                                                                                        Prompts 是 Server 预定义的消息模板,由用户在 Host 的界面中主动选择触发(如 Cursor 的斜杠命令)。Host 调用 prompts/get 获取预组装的消息数组,直接注入对话上下文:

                                                                                                          // 请求
                                                                                                          {
                                                                                                            "jsonrpc": "2.0",
                                                                                                            "id": 3,
                                                                                                            "method": "prompts/get",
                                                                                                            "params": {
                                                                                                              "name": "review-doc",
                                                                                                              "arguments": { "doc_id": "authentication" },
                                                                                                              "_meta": {
                                                                                                                "protocolVersion": "2026-07-28",
                                                                                                                "clientInfo": { "name": "cursor", "version": "0.50" }
                                                                                                              }
                                                                                                            }
                                                                                                          }

                                                                                                            // 响应
                                                                                                            {
                                                                                                              "jsonrpc": "2.0", "id": 3,
                                                                                                              "result": {
                                                                                                                "messages": [
                                                                                                                  {
                                                                                                                    "role": "user",
                                                                                                                    "content": {
                                                                                                                      "type": "text",
                                                                                                                      "text": "请按照写作规范审校以下文档,检查标题层级、术语用法和代码块标注..."
                                                                                                                    }
                                                                                                                  }
                                                                                                                ]
                                                                                                              }
                                                                                                            }

                                                                                                            Prompts 的核心价值在于将领域知识固化在 Server 侧:审校规则、输出格式、上下文组装逻辑均由 Server 维护,用户无需每次手动编写复杂的 prompt。模板支持参数化(如 doc_id),由 Host 在调用时注入具体值。

                                                                                                             2.5 反向能力:Sampling 与 Elicitation

                                                                                                            前述三种原语均属于 Host → Server 方向的交互:Host 发现能力、调用工具、读取资源。MCP 还定义了两种 Server → Host 方向的能力,使 Server 在处理请求时可以反向利用 Host 侧的资源。

                                                                                                            Sampling:委托模型推理

                                                                                                            Server 在执行工具逻辑时,有时需要模型的推理能力,但 Server 本身并不持有模型。Sampling 机制允许 Server 向 Client 发送 sampling/createMessage 请求,由 Host 调用自身的模型完成一次推理,再将结果返回给 Server。

                                                                                                            典型场景:日志分析 Server 接收到一段 5000 行的原始日志,自身不具备文本摘要能力,于是通过 Sampling 请求 Host 调用模型提取关键错误信息,获得摘要后再执行后续分析。

                                                                                                            Host 对 Sampling 请求拥有完全控制权——可以拒绝请求、修改 prompt 内容,或通过弹窗向用户请求确认。Server 无法绕过 Host 直接操控模型。

                                                                                                            Elicitation:向用户征集信息

                                                                                                            Server 执行过程中可能缺少关键输入。Elicitation 允许 Server 向 Client 发送 elicitation/create 请求,由 Host 向用户展示表单或确认对话框,收集用户输入后回传给 Server。

                                                                                                            典型场景:部署工具检测到存在多个可选环境,通过 Elicitation 请求用户选择"部署到 staging 还是 production";或数据库工具在执行 DROP 操作前,请求用户输入确认文本。

                                                                                                            两种反向能力的共同特征:请求由 Server 发起,但控制权始终归属于 Host 和用户。Host 可拒绝任何反向请求,Server 无法直接触达用户。

                                                                                                             2.6 Tool Annotations

                                                                                                            注册工具时可附加 annotations,向 Host 声明工具的行为特征:

                                                                                                            tools/list 返回的每个工具都携带自己的注解,例如:

                                                                                                              {
                                                                                                                "name": "search-docs",
                                                                                                                "title": "搜索文档",
                                                                                                                "description": "按关键词搜索文档标题和内容",
                                                                                                                "inputSchema": { "type": "object", "properties": { "query": { "type": "string" } } },
                                                                                                                "annotations": {
                                                                                                                  "readOnlyHint": true,
                                                                                                                  "destructiveHint": false,
                                                                                                                  "idempotentHint": true,
                                                                                                                  "openWorldHint": false
                                                                                                                }
                                                                                                              }

                                                                                                              search-docs 声明自己是只读、幂等且不访问外网的查询工具——Host 据此可以免确认、允许自动重试,并适度放宽沙箱限制。而一个删除类工具通常会声明 destructiveHint: true、idempotentHint: false,促使 Host 展示确认对话框。

                                                                                                              字段名中的 Hint 后缀是规范的刻意设计——注解仅作为参考建议,不构成安全约束。具体原因由下文的信任模型进一步阐述。

                                                                                                               2.7 信任边界

                                                                                                              MCP 涉及多方参与者,厘清信任关系是做出正确安全决策的前提:

                                                                                                              三条核心原则:

                                                                                                              1. Host 信任用户,不信任 Server。Server 提供的 Tool Annotations、工具描述、返回内容均可能包含恶意信息。Host 必须对破坏性操作执行独立校验(如展示确认对话框),不应仅凭 destructiveHint: false 就跳过安全确认。

                                                                                                              2. Server 不信任 Client。任何请求参数均可能被伪造,Server 必须执行输入校验与权限检查,不应假定 Client 一定来自合法 Host。

                                                                                                              3. 反向能力受 Host 管控。Sampling 和 Elicitation 请求由 Host 拦截与审核,Server 无法绕过 Host 直接触达模型或用户。

                                                                                                              这正是 Tool Annotations 采用 Hint 后缀的设计意图——它们属于 Server 的自我声明,而非 Host 的安全策略。Host 可将注解作为 UI 提示的参考依据,但安全决策必须基于自身的策略引擎。

                                                                                                              03

                                                                                                              本地 vs 远程

                                                                                                               3.1 协议演进

                                                                                                              在展开两种部署模式之前,先简要回顾协议的关键演进节点。若在早期文档或代码中遇到 initialize、SSE transport、session ID 等概念,它们属于历史版本,当前规范已不再使用。

                                                                                                               3.2 从本地到远程

                                                                                                              MCP 最初仅支持本地部署:Host 启动一个子进程,通过 stdin/stdout 通信。这种模式适用于本机文件访问、个人密钥管理、开发者本地安装的工具等场景——进程与编辑器共存,配置存储于本机,通过环境变量注入 API Key 即可运行。

                                                                                                              但本地模式很快暴露出局限性:

                                                                                                              • 分发成本高:团队 20 人使用同一个内部工具,每人均需安装 Node、配置环境变量、跟踪版本。Server 升级后,全员需要同步更新。

                                                                                                              • 凭证管理分散:API Key 存储于各开发者的本机配置中,无法集中吊销、轮换,审计也难以实施。

                                                                                                              • SaaS 无法开箱即用:Stripe、Sentry、Vercel 等云服务无法接受"先安装依赖、配置环境变量"的接入门槛——这类服务的预期接入形态是仅提供一个 URL,配置后即可使用。

                                                                                                              • 无法跨设备共享:同一套能力仅存在于一台机器上,云端 Agent、CI 流水线、移动端 Host 均无法接入。

                                                                                                              远程 MCP(Streamable HTTP)正是为解决这些问题而设计的:Server 由提供方统一部署与维护,Client 仅需配置一个 URL;鉴权采用 OAuth 2.1,权限与 token 集中管理;一个端点可同时服务 Cursor、Claude、自研产品等多种 Host。本地模式并未消失,而是适用边界更加明确——本机能力继续使用 stdio,共享能力和第三方服务使用远程模式。

                                                                                                               3.3 传输机制

                                                                                                              stdio:Host 启动一个子进程,stdin 发送请求、stdout 接收响应。每条消息是独占一行的完整 JSON-RPC 对象,以换行符分隔。

                                                                                                              这意味着 console.log 会破坏协议——stdout 中混入非 JSON-RPC 文本会导致 Client 解析失败,连接立即中断。所有日志输出必须使用 console.error(stderr)。

                                                                                                              stdio 模式下,进程存活期间复用同一个 Server 实例,工厂函数仅在启动时执行一次。适用于存在初始化开销的场景:建立数据库连接池、加载搜索索引等。

                                                                                                              Streamable HTTP:Client 对 Server 的 URL(如 https://mcp.vercel.com)发送 POST 请求。响应有两种格式,取决于 Accept 请求头:

                                                                                                              • JSON:标准请求-响应模式,Content-Type: application/json,适用于快速操作

                                                                                                              • SSE 格式响应流:Content-Type: text/event-stream,服务端可推送多条消息——进度通知、中间结果——最后一条为完整响应

                                                                                                              默认每个 HTTP 请求相互独立、无会话状态——工厂函数在每次请求时执行,请求结束后即释放,任意实例均可处理任意请求。仅当 Client 需要接收服务器主动推送的通知时,才协商可选会话。跨请求的业务状态(如工作流 ID)需由 Client 在每次请求中显式传递。

                                                                                                               3.4 为何弃用 SSE 长连接

                                                                                                              早期远程传输采用 HTTP + SSE 双通道设计(2025-03 引入,2025-11 废弃,生命周期仅八个月)——先通过 GET 建立 SSE 长连接,后续请求 POST 至另一端点,两条通道靠 Mcp-Session-Id 关联。该架构的根本缺陷是双通道与强制有状态:

                                                                                                              • 双通道拼接:旧设计将通信拆分为两条独立的 HTTP 通道——Client → Server 的请求通过 HTTP POST 发送,Server → Client 的消息通过由 Client 发起的 GET SSE 长连接返回。两条通道依赖 session ID 手工关联,任一连接中断都会破坏完整的通信链路。

                                                                                                              • 强有状态:服务器须在内存中维护"session ↔ SSE 连接"的映射。负载均衡需配置会话粘滞以保证两条通道路由至同一实例;服务器重启或扩容即丢失全部会话,无法水平扩展,亦不适配不支持长连接的 Serverless 平台。

                                                                                                              • 恢复困难:SSE 长连接中断期间的推送无法补发,Client 只能重建会话,存在消息丢失窗口。

                                                                                                              • 基础设施不友好:长连接占用连接资源,且 GET + SSE 流难以被企业代理、CDN 等标准 HTTP 基础设施统一处理。

                                                                                                              Streamable HTTP 正是为规避上述缺陷而设计:所有消息 POST 至同一端点,SSE 从独立传输通道降格为请求作用域的响应格式,无状态成为默认、会话成为可选。两者对比:

                                                                                                               3.5 Vercel MCP 案例

                                                                                                              Vercel MCP 将上述远程模式落地为一个具体的产品实现。所有 Host 仅需配置同一个 URL 即可接入,无需各自重复实现 Vercel 集成——这正是第 1 章 M+N 方案的典型实践。

                                                                                                                {
                                                                                                                  "mcpServers": {
                                                                                                                    "vercel": { "url": "https://mcp.vercel.com" }
                                                                                                                  }
                                                                                                                }

                                                                                                                鉴权:OAuth 2.1 握手

                                                                                                                首次连接时,Server 返回 401 并在 WWW-Authenticate 响应头中携带 OAuth 元数据。Host 自动引导用户完成授权流程,获取 token 后所有后续请求携带 Bearer 凭证。凭证由 Vercel 集中签发、轮换与吊销,不再分散存储于各开发者本机的 .env 文件中。

                                                                                                                权限裁剪:同一端点,差异化能力

                                                                                                                同一个 URL 根据 token 的 scope 动态裁剪 tools/list 的返回结果:

                                                                                                                实际效果

                                                                                                                当用户提出"my-app 最近一次部署为什么失败"时,模型自动编排工具调用链,全程无需打开 Dashboard 或执行 vercel logs:

                                                                                                                小结:Vercel MCP 恰好对应远程模式需要解决的四个核心问题:

                                                                                                                1. 统一端点分发 — Cursor、Claude、VS Code 通过同一 URL 接入

                                                                                                                2. OAuth 集中管控凭证 — 集中签发与吊销,取代分散的本机环境变量管理

                                                                                                                3. 按权限暴露能力 — 同一端点根据 scope 动态裁剪工具列表

                                                                                                                4. 破坏性操作隔离 — 写操作独立为单独工具,Host 可在调用前拦截确认

                                                                                                                04

                                                                                                                总结

                                                                                                                MCP 的核心思路可以用一句话概括:在 AI 应用与外部系统之间插入一层标准协议,将 M×N 的集成问题降为 M+N。

                                                                                                                围绕这一目标,协议定义了三个层面的机制:

                                                                                                                • 能力暴露:Server 通过 Tools、Resources、Prompts 三种原语向 Host 暴露能力,各原语按控制权归属区分——模型驱动、应用注入、用户选择。Server 还可通过 Sampling 和 Elicitation 反向利用 Host 侧的模型推理与用户交互能力,但控制权始终归属 Host。

                                                                                                                • 安全模型:Host 不信任 Server,Server 不信任 Client。Tool Annotations 是建议而非约束,安全决策由 Host 的策略引擎独立执行。

                                                                                                                • 部署模式:本机能力使用 stdio,共享能力和第三方服务使用 Streamable HTTP。远程模式天然无状态,配合 OAuth 2.1 实现集中鉴权与权限裁剪。

                                                                                                                理解这三个层面,就具备了评估"是否该用 MCP"以及"如何设计一个 MCP Server"的基础认知。

                                                                                                                 参考资料

                                                                                                                MCP 规范(2026-07-28) :https://modelcontextprotocol.io/specification/2026-07-28/basic

                                                                                                                TypeScript SDK v2 文档 :https://ts.sdk.modelcontextprotocol.io/v2/index.html

                                                                                                                Anthropic 发布公告: https://www.anthropic.com/research/model-context-protocol

                                                                                                                a16z 播客:MCP 共创者访谈: https://a16z.com/podcast/mcp-co-creator-on-the-next-wave-of-llm-innovation/

                                                                                                                Vercel MCP 文档: https://vercel.com/docs/mcp

                                                                                                                -End-

                                                                                                                原创作者|陈畅

                                                                                                                感谢你读到这里,不如关注一下?👇

                                                                                                                扫码领取腾讯云开发者专属服务器代金券!

                                                                                                                图片

                                                                                                                跳转微信打开

                                                                                                                代码秒出,验证排队?AI Coding 的隐性账单

                                                                                                                2026年10月30日 08:45

                                                                                                                原创 李晓鹏 2026-10-30 08:45 广东

                                                                                                                关注腾讯云开发者,一手技术干货提前解锁👇

                                                                                                                开发者公众号专属群聊

                                                                                                                扫码加入获取更多一手教程、科技前沿报告

                                                                                                                进入 2026 年,用 AI 辅助开发已是许多研发团队的日常,我们团队也不例外。代码确实写得更快了,但在实际交付中,我们和不少团队一样,都遇到了一个问题:“代码写得更快了,为什么交付效率的提升没有那么明显?”围绕这个问题,我们做了一些实践和探索,也开始重新思考:编码省下的时间去了哪里?要让整个交付过程更快,除了用好 AI,还需要改变什么?本文就是对这些实践和思考的一次整理,尝试借助信息论的视角理解其中的原因,也讨论团队协作和研发平台可以怎样改进。把这些想法写出来,希望能和有类似经历的朋友一起探讨、交流。

                                                                                                                 摘要

                                                                                                                Vibe coding 显著提高了代码的开发速度,但不会自动带来同等幅度的需求交付效率。一份需求通常只说明要解决什么问题,真正开始实现时,还要确认业务规则、现有系统限制、异常处理方式和验收标准等。这些内容需要通过需求梳理、功能设计、技术方案评审等环节逐步补齐。如果开发者没有在上下文中告诉 AI,也没有让 AI 从现有代码中查到,模型就只能按照常见做法作出猜测,并把猜测写进代码。

                                                                                                                开发者通过 chat 向 AI 说明需求时,或者需求从产品、架构、开发传到测试时,一些依赖经验和具体场景的细节也容易被省略。随着 AI 生成的代码越来越多,人的检查能力、系统集成速度和运行反馈会逐渐跟不上,返工、维护负担和代码腐化也会随之增加。因此,AI coding 能带来多大收益,取决于任务本身。规格明确、容易验收的日抛型应用,更容易把生成速度转化为交付速度;规则复杂、系统关联多、需要长期维护的应用,则收益提升有限。

                                                                                                                此外,当需求在不同岗位之间反复转述,就容易遗漏背景和关键约束。为减少这种损耗,AI Native 组织可以围绕完整交付组建由超级个体和小团队构成的交付单元,让同一批人基于 AI 贯通需求、实现、验证与运行反馈。但个人和团队负责的范围不能随代码生成能力同步扩大,仍然受验证能力、专业知识和上线后的运行保障能力限制,组织统一的研发平台与专业人员支持。

                                                                                                                研发平台也不能只把多个 coding agent 与 CI/CD 流程串联起来,而应保存每次变更依据的事实和执行记录,提供独立验证,并把上线结果带回需求判断,再根据这些证据逐步扩大自动执行范围。模型能力的提升会让 agent 更好地完成需求,但不会自动补齐缺失的业务信息,也不会替代独立验证。

                                                                                                                最后,衡量研发是否提效,应看能否在质量要求不变的前提下,更快、更稳定地把需求转化为可靠的能力。只有需求信息更容易获得和传递,生成结果更容易验证,运行反馈也能及时返回,编码提速才会转化为稳定的交付提效。

                                                                                                                01

                                                                                                                Vibe Coding 与 SDLC:生成提速,信息瓶颈未变

                                                                                                                 1.1 编码提速与交付提效之间的信息缺口

                                                                                                                AI 加快了代码生成,vibe coding 也让自然语言驱动的开发更容易启动。然而,编码速度提高以后,软件研发生命周期(SDLC)的整体效率未必同步提高。信息论提供了一个分析视角:沿着真实约束的形成、传递和确认过程,寻找代码生成之外的交付瓶颈。

                                                                                                                代码是需求的一种完全指定表述。在给定语言语义、依赖和运行环境后,代码必须把原本未决的选择固定为具体行为,但这些选择未必符合真实需求。

                                                                                                                需求文档省略的细节,通常由开发者根据领域知识、系统现状和历史经验补齐。AI 能快速生成常规代码,却未必掌握这些依据,因此可能把猜测固化为实现。真正影响结果的是还有哪些关键选择没有确定,以及这些选择是否有真实依据;prompt 的文本长度不能代替这些信息。

                                                                                                                本文所说的纯 vibe coding,是指主要依靠自然语言让 AI 生成代码,再根据局部运行效果反复修改,却缺少系统理解、明确约束和独立验证的开发方式。生成速度提高后,未经确认的假设也会更快进入代码,并在后续修改中不断累积。

                                                                                                                本文将用一个假设的电商需求贯穿讨论:“用户取消已付款、未发货的订单后自动退款,减少联系客服的等待。”

                                                                                                                 1.2 需求信息的来源与 AI 实现的边界

                                                                                                                业务需求的依据来自用户行为与诉求、业务流程限制、运行环境和已有系统约束等。

                                                                                                                需求并不是一开始就完整存在、只待向下传递的一组信息。用户知道痛点,未必知道功能应该怎样设计;系统存在限制,团队也未必已经发现;“速度更快”和“结果完全一致”之间还可能需要取舍。这些信息需要通过访谈、观察、实验和工程调查逐步形成,并根据测试与运行反馈持续修正。

                                                                                                                以退款需求为例,退款是否到账,需要查询支付渠道和账务证据;取消与发货能否同时发生,需要确认业务规则。这些信息不会随着“自动退款”几个字自动进入模型。即使模型生成了接口调用和状态更新,也无法仅凭这句需求确定重试规则和成功判据。缺少实际流程与渠道约定时,这些实现仍然只是待确认的假设。

                                                                                                                从信息论看,可以把 SDLC 类比为一条将业务意图转化为实现的有噪信道。真实目标和约束是有效信号,遗漏会造成信号损失,误解和无依据的补全则会引入噪声。各研发环节承担的信息处理工作如下:

                                                                                                                图 1:软件研发中的信息路径与反馈

                                                                                                                这一类比需要区分信息尚未形成、传递中遗漏和实现未遵守已有约束三种情况,不能把研发理解为只传递固定消息的过程。沿着这条信息路径进入代码的内容,可以按形成方式作如下分类:

                                                                                                                Ispec 是需求中已经说清楚的显式指定信息;Iredundant 是按照现成规则就能展开的结构冗余;Itacit 是需求没有写明、实现时却必须作出的隐性决策。这个式子只是按形成方式对代码内容分类。三类内容可能重叠,不能将其理解为严格的熵相加,也不能据此计算代码包含多少比特的信息。

                                                                                                                结构冗余主要来自语言语法、框架要求和项目惯例。只要环境和规则明确,AI 通常能快速生成这些常规代码。隐性决策则取决于项目的真实情况:接口约定、异常处理、性能目标、旧系统限制、团队要求和历史故障。AI 熟悉常见写法,却不知道当前项目应该采用哪一种选择。

                                                                                                                大模型会根据训练形成的先验和当前上下文生成候选实现。上下文缺少事实时,模型可能作出合理推断,但“很可能如此”不能证明它符合当前系统。语法正确、语义合理、与真实约束错位,可以同时发生。

                                                                                                                例如,模型可能先查询订单是否“未发货”,再执行取消和退款。代码语法正确,单次测试也能通过;但如果发货流程在查询后、取消前推进,系统就可能同时发货和退款。实现能否成立,取决于当前系统如何保证取消与发货不能同时成功,这项约束无法依靠常见写法猜出来。

                                                                                                                因此,AI 编码的收益取决于代码的信息构成。结构冗余多、隐性决策少时,生成收益更容易兑现;隐性决策密集时,收益则取决于获取上下文和核对结果需要付出多少成本。这种关系只能判断收益趋势,不能直接换算成固定的加速倍数。

                                                                                                                 1.3 Chat 中的上下文抽取与信息损耗

                                                                                                                隐性决策需要真实依据。通过 chat 提供上下文时,开发者需要从掌握的领域规则、历史经验和系统细节中筛选与任务有关的内容,再组织成文字。chat 承载的是这些信息经过筛选后的表达,不能假设某个 prompt 已经包含实现所需的全部约束。

                                                                                                                尚未发现的约束无从写入,已经掌握的知识也可能在筛选和表达时丢失。对于上下文丰富的研发任务,把已有知识转成 chat 文字通常是一次有损压缩:没有被选中、难以表达或被简化的信息,无法仅靠这段文字可靠恢复。

                                                                                                                信息损失在模型接收之前就已经发生。开发者可能知道退款重试“需要按老办法处理”,却没有写出老办法中的去重条件;模型收到“失败后重试”后,只能在缺少约束的地方选择一种常见实现。它能补全表达,却无法保证补回被省略的事实。

                                                                                                                把脑中的知识整理成文字,再核对生成结果是否符合要求,本身就需要时间。说明太少,容易遗漏关键约束并增加返工;说明得更充分,又会增加准备和检查成本。

                                                                                                                图 2:chat 中的上下文抽取与信息损耗

                                                                                                                传统编码中,开发者可以直接用已有经验作出实现判断。例如,他知道退款接口需要防重,就会把约束直接落实到状态变化中。委托 AI 后,这份知识必须先被开发者说出来或写下来,模型才能使用。“说清楚比自己写还累”,说明代码实现成本下降后,知识交付成本仍可能上升。

                                                                                                                多轮 chat 可以逐步补齐遗漏,但前提是人先发现问题。对话更长,只能说明传输了更多文字,不能保证重要约束已经完整表达,也不能保证前后说明一致。只要人还没有意识到某项约束,重传就不会发生。

                                                                                                                这里所说的有损压缩,是指任务相关信息无法从 chat 内容中完整重建,并不表示自然语言必然丢失关键要求。有限而明确的约束可以完整表达;困难在于,有些约束只有遇到具体问题才显得重要。例如,退款超时以后,团队才可能意识到:没有收到成功响应,不代表退款没有发生,直接重试可能造成重复退款。

                                                                                                                减少损耗,需要改变信息进入模型的方式。模型应直接查阅当前契约、历史故障测试和运行证据,chat 主要说明本次新增的要求和未决取舍。团队还要筛选这些资料、标明适用版本并更新过时规则,使人不必每次凭记忆重新讲述。契约和领域知识应与代码同步更新,并采用同库、同版本管理。

                                                                                                                 1.4 生成与验证的带宽不对称,验证成为新的效率瓶颈

                                                                                                                开发者通过 chat 交代需求和上下文,AI 据此生成代码。代码生成以后,还要检查它是否符合需求、遵守系统约束。这里的“验证带宽”,是指单位时间内能够可靠检查多少代码。AI 可以快速生成大量代码,但生成能力扩大,并不意味着可靠验证能力同步扩大。

                                                                                                                当新变更进入的速度超过验证速度,待检查的代码就会积压。坚持完整检查,交付就要排队;放宽检查,问题可能进入集成或运行阶段,随后引发缺陷和返工。生成阶段节省的时间,会被下游的等待和修复成本抵消。

                                                                                                                多轮 chat 可以形成“发现错误—反馈—修正”的循环,类似 ARQ(自动重传请求)。然而,纠错必须从发现错误开始。验收由人主导时,人没有发现的问题就不会触发修正。自动测试可以分担检查工作,前提是已经存在明确、有效的判据,能够识别违反约束的行为。因此,真正限制这个循环速度的,仍是负责验收的人能否及时发现错误。

                                                                                                                本文把确认 AI 产出所增加的人力称为验证税,并将它与原本就需要的评审和测试区分。计算交付的净收益时,要从生成节省中扣除新增的上下文整理、核验、修正和返工成本。只要关键约束仍留在人脑中,人的识别和判断能力就仍是验证瓶颈。

                                                                                                                chat 遗漏的知识需要人重新补充,再据此确认实现。自动化工具可以检查已经明确的规则,却无法保证找回被遗漏的规则。要提高可靠验证能力,还要把隐性知识转成可复用的契约和检查,逐步减少对个人记忆与反复核验的依赖。

                                                                                                                公开研究也观察到了这种下游负担。Faros AI 在 2025 年研究了逾 10,000 名开发者和 1,255 个团队,并比较各团队的低、高 AI 采纳期:PR 数量增加、单次变更变大,评审时长也随之上升(图 3)。Sonar 2026 年的调查中,38% 的受访者认为,评审 AI 代码比评审同事编写的代码更费力。

                                                                                                                图 3:AI 采纳上升时的 PR 产出、变更规模与评审时长

                                                                                                                评审时长不等于新增人工工时。两项研究覆盖 AI 辅助开发,分别是观察研究和自报调查,不能据此认定纯 vibe coding 的因果效果。

                                                                                                                 1.5 纯 Vibe Coding 的代码为何会快速腐化

                                                                                                                代码腐化往往从缺失的约束被默认实现替代开始。在退款案例中,模型不知道重试必须保持为业务上的同一次退款,于是生成了普通的再次调用。一次演示成功后,这个未经确认的选择就成为后续代码的依赖;暂时没有出问题,也让假设看起来像已经确认的事实。

                                                                                                                随后,开发工作开始围绕局部症状推进。退款重复了,就在接口外增加一个判断;页面状态不对,就在前端补一份退款逻辑;回调延迟了,再增加一条状态更新路径。每个补丁都可能暂时解决眼前的问题,但如果没有回到领域规则和系统不变量,代码就会不断堆积,缺少统一的抽象和管理,不同逻辑之间还可能相互冲突。

                                                                                                                代码生成成本降低后,团队也更容易继续增加实现,而不是理解并合并已有逻辑。新增功能比删除不必要的状态更容易展示进展。同一个业务概念出现多个版本后,一次规则变化就要同步修改多个位置,维护者却未必知道这些逻辑分布在哪里、彼此怎样依赖。

                                                                                                                图 4:纯 vibe coding 的代码腐化路径

                                                                                                                这个过程还会自我强化。未经证实的假设进入代码库后,后续生成又把现有代码当作上下文,早期误判便可能被继承为项目惯例。模型依据局部代码继续生成时,会进一步巩固全局的不一致;每次局部修复,又会扩大以后需要理解和验证的范围。

                                                                                                                这里会积累三类技术债:尚未确认的实现假设、缺少来源的设计决策,以及本应复用却被反复复制的结构。它们不是技术债的全部,却都会增加下一次修改时的理解和验证成本。最终,代码越来越多,团队却越来越难判断修改哪里才安全。

                                                                                                                因此,代码腐化不能简单等同于“代码熵增”。当代码持续增加,而信息缺口、验证积压和代码冗余没有得到治理时,腐化就会加快。手写代码也可能进入这条路径,但 AI 降低了继续生成和打补丁的成本,从而放大了这个过程。

                                                                                                                 1.6 编码提速后的瓶颈迁移与下游负担

                                                                                                                即使不考虑代码腐化,只提高编码效率也存在结构上限。在工作量固定、其他阶段耗时不变的串行模型中,可以用阿姆达尔定律表示这一上限:

                                                                                                                p是编码占原始总耗时的比例,k是编码加速倍数,S是端到端加速比。即使编码接近瞬间完成,也只能省去原来用于编码的时间。真实项目还有并行、依赖和排队,不能直接把个人活动时间占比当作项目的日历周期占比。

                                                                                                                下表假设需求范围不变,并用相对耗时展示下游成本如何抵消编码阶段的局部收益。

                                                                                                                注:示意性结构,非某团队实测值。

                                                                                                                阿姆达尔定律解释了未被加速的工作如何限制整体收益;表中增加的评审与修复成本,则是在这个上限之外进一步抵消收益。两者不能混为一谈。

                                                                                                                代码生成增加后,下游负担还会继续扩大。更大的 diff 要求评审者同时理解更多选择,更多变更会触及更多回归关系,更频繁的发布也需要更可靠的发布和恢复能力。这些额外工作由变更数量和规模增加引起,却往往由评审、测试和运维人员承担。

                                                                                                                验证失败后,工作还会返回上游:补充需求、修改设计、重写代码,然后再次进入检查。返工会继续占用有限的需求和验证资源。生成越快、错误发现得越晚,返工就越容易与新需求争夺同一批人员。故障和返工增加可能由这一机制引起,但不能仅凭 AI 生成代码的采纳率上升,就认定两者存在因果关系。

                                                                                                                 1.7 杠杆在信道两端:知识显式化与信任重建

                                                                                                                在 vibe coding 场景中,AI 承担了更多代码生成工作,研发人员的投入随之向 SDLC 两端移动:向左参与需求、约束和规格的形成,向右承担实现审查、系统验证和持续运行。编码工作减少了,知识显式化和正确性确认却需要投入更多精力。

                                                                                                                图 5:vibe coding 下研发人员向需求与验证两端移动

                                                                                                                向左移动,需要把原本直接参与个人编码判断的知识,提前转化为 AI 可以使用的信息,也就是知识显式化。接口约定、功能演进和业务例外都要整理成上下文、契约和验收条件,已经知道的未决问题也要明确标出。过去可以边理解边实现,现在还要为表达、维护和传递这些知识投入时间。只有当这些信息能够反复复用,并减少后续猜测与返工时,显式化成本才会逐步摊薄。

                                                                                                                向右移动的成本,来自信任建立方式的变化。传统开发中,开发者在编写代码的过程中逐步理解决策理由、依赖关系和边界处理。AI 生成代码时,开发者没有经历这个过程,只能通过代码审查、测试和运行结果重新建立理解,并确认 AI 是否正确处理了业务规则和异常情况。生成的代码越多,需要重新理解和检查的内容通常也越多,建立可靠信心所需的时间也会增加。

                                                                                                                对 AI 生成的代码,应按照默认不信任的原则验收。退款接口调用成功,只能证明本次请求路径能够运行,不能证明超时重试不会造成重复退款,也不能证明取消与发货的竞争已经正确处理,或延迟回调不会破坏状态。验证必须从“能够运行”深入到业务不变量、异常路径和系统影响。

                                                                                                                验证证据还要独立于生成过程。让模型根据自己的实现反推测试,可能把同一个误解同时写进代码和断言。测试应由契约、历史故障和独立反例约束。代码看起来合理、单次调用成功或覆盖率较高,都不能代替这些证据。

                                                                                                                运行反馈还要检验需求本身是否有效。退款逻辑正确以后,团队仍要确认到账等待和客服求助是否真正改善。如果反馈到达得太晚,生成提速就可能让更多代码建立在未经证实的需求上。缩短反馈路径,团队才能更早决定继续、调整或停止投入。

                                                                                                                因此,评估研发提效时,需要同时计算两端新增的投入。可复用的上下文能够降低左侧的知识交付成本,独立且可自动执行的检查能够降低右侧的验证成本。AI 应参与这两类工作,不能只扩张中间的代码生成能力。

                                                                                                                02

                                                                                                                提效边界:从日抛型应用到复杂系统

                                                                                                                AI 编码的收益因任务而异。隐性约束越少、验收越直接、生命周期越短,生成节省的时间就越容易转化为交付提效。系统关联越多、验证范围越大、维护时间越长,首次生成的收益就越容易被后续成本抵消。

                                                                                                                 2.1 日抛型应用最容易兑现生成收益

                                                                                                                日抛型应用逻辑简单、生命周期短,通常用完即丢。这类任务输入明确、验收直接,也很少受历史系统约束。代码多为常规结构,AI 可以快速生成;业务方验收后,通常无须承担集成和长期维护成本。

                                                                                                                例如,退款需求如果只做交互原型,可以使用虚构订单和模拟的到账结果。业务方点击取消,确认页面状态和操作流程符合预期,随后即可删除原型。生成节省的时间很少被后续成本抵消,因此更容易体现 AI 编码的收益。

                                                                                                                 2.2 复杂系统会放大信息损耗与验证成本

                                                                                                                复杂系统要在已有系统上继续演进。一次修改既要实现当前功能,也要满足兼容、性能、一致性、安全和可靠性要求,并避免破坏其他组件与调用方。AI 可以加快代码生成,但系统原有的关联不会随之消失。

                                                                                                                同一个退款功能,在原型中只需完成“点击取消,显示退款成功”。接入真实支付、库存和发货流程后,一次取消可能正好遇上仓库发货;退款请求可能已经被渠道受理,系统却因等待超时再次发起;延迟回调还可能覆盖新的订单状态。此时,接口调用成功只能证明一条路径跑通,无法证明整套状态变化正确。

                                                                                                                在这些系统关联之上,AI 编码还会叠加信息损耗。相关规则分散在代码、文档、历史故障和团队经验中,经由 chat 和任务交接进入模型时,可能被压缩或遗漏。如果实现与测试沿用同一份不完整的上下文,错误假设还可能同时进入代码和验证。系统关联越多,查证、回归和人工判断的成本就越高。

                                                                                                                因此,在复杂系统中,AI 节省的编码时间往往会被上下文搜集、集成验证、异常处理和后续维护抵消一部分,净收益通常明显低于日抛型应用。复杂系统能否真正获得收益,取决于系统事实能否充分进入上下文,以及变更能否通过独立证据完成验证。

                                                                                                                03

                                                                                                                从超级个体到 AI Native 组织:缩短交付链,补足个人边界

                                                                                                                在复杂系统中,关键事实分散在多个组件和专业领域,仅靠自动检查还无法覆盖所有未知约束,因此人仍需承担需求判断、异常处理和质量责任。研发人员的工作向需求与验证两端移动后,能否持续掌握业务目标、实现约束与验收依据,就成为影响交付效率的关键。

                                                                                                                超级个体与 AI Native 组织分别从个人和组织层面减少交接损耗,使目标、约束和责任贯穿完整交付过程。

                                                                                                                 3.1 超级个体如何减少交付链中的信息损耗

                                                                                                                本文所说的超级个体,是指在明确范围内借助 AI 贯通需求、实现和验证,并对交付结果负责的研发人员。

                                                                                                                超级个体可能提高端到端效率,一个重要原因是减少了需求在岗位之间的反复转述。这个过程可以用信息论中的数据处理不等式解释。设原始需求为 X、产品表达为 Y、开发理解为 Z。如果开发只能依据产品表达理解需求,无法直接查阅原始材料或获得新的证据,三者就构成马尔可夫链 X → Y → Z:

                                                                                                                其中,互信息 I(X; Y) 衡量产品表达中包含多少原始需求信息,I(X; Y) 衡量开发理解中还保留多少原始需求信息。数据处理不等式说明,继续摘要、解释 Y 或根据 Y 生成实现,都不能凭加工本身增加关于 X 的信息。产品在交接时省略的约束,开发无法仅靠推断可靠恢复。只有直接访问原始需求、用户反馈或领域专家,开发才能获得新的信息,打破这条单纯的传递链。

                                                                                                                因此,超级个体的价值不仅在于提高个人产出,还在于让同一责任人更接近原始信源,并持续掌握目标、约束和验证依据。以退款需求为例,他在接收“取消后自动退款”之后,还会直接确认用户联系客服的原因,保留退款进度可见性、取消规则和重试约束,并按照这些依据检查异常路径与到账结果。相关知识仍需明确表达给 AI,但同一项约束无须在岗位接力中反复压缩,再由下一位参与者重新理解。

                                                                                                                交付上下文保持连续,可以降低交接成本,却也扩大了个人需要承担的责任。只掌握局部编码技能,难以完成端到端交付。超级个体需要想得明白、表达得清楚,同时能够落地实施:既能定义问题和传达约束,也能判断实现与验证结果。AI 降低了代码编写门槛,却没有替人完成这些判断。

                                                                                                                只要人仍是软件研发质量的第一责任人,端到端能力就会变得更加重要。在任务边界明确,并且能够获得可靠验证和专业支持时,超级个体和端到端小团队更有可能减少交接损耗,提高交付效率。

                                                                                                                 3.2 超级个体需要具备的能力基础

                                                                                                                想得明白”需要领域理解和系统判断,“表达得清楚”需要把约束写得可以传递、可以验收,“能够落地实施”则需要组织 AI 和工具完成实现、独立验证结果,并处理上线后的问题。这三项要求可以进一步落实为六类具体能力。

                                                                                                                AI 可以完成部分编码操作,但责任人仍要判断变更会影响哪些系统、异常会怎样传播,以及验证结果能否支持交付决定。

                                                                                                                当负责的任务逐渐增多时,超级个体也不能每次都从头理解和验证。故障原因、业务取舍和验证结果需要沉淀为契约、测试和决策记录,供后续任务直接复用。否则,任务越多,团队对超级个体个人经验的依赖就越重,端到端效率也越难持续提高。

                                                                                                                 3.3 超级个体的验证瓶颈与责任边界

                                                                                                                超级个体在减少岗位交接的同时,也把原本由多人承担的判断、验证和运行责任集中到了一个人身上。因此,个人能负责多大范围,取决于他能否验证 AI 产出、发现自己的认知错误,并持续对上线后的运行结果负责。

                                                                                                                最直接的限制来自验证能力。由于 AI 可以并行完成多个编码任务,而人的注意力、跨领域理解和验证能力有限,当代码编写能力增长快于个人对需求和实现的验证能力时,就会造成工作积压,人也会成为需求交付的瓶颈。此时继续生成代码,只会增加等待验证的内容。

                                                                                                                更隐蔽的风险是同源错误。如果同一个人误解了退款重试规则,AI 可能沿用这项错误假设生成需求说明、实现和测试。三者看起来相互一致,实际却可能共同偏离业务事实。因此,关键规则仍需由领域负责人、支付专家或独立契约检查进行验证,不能只依靠同一套上下文自我证明。

                                                                                                                即使功能已经通过验证并上线,责任也没有结束。超级个体还需要观察系统运行情况、处理异常并准备恢复方案,不能用“AI 写的”解释事故;关键决策、运行记录和处理方法也要能被他人接替。因此,个人负责范围的扩大,应建立在可靠验证和专业协作之上。证据不足时停止交付,超出能力范围时引入专业人员,也是端到端负责的一部分。

                                                                                                                 3.4 AI Native 组织:小型交付单元、共享平台与专业保障

                                                                                                                要弥补个人能力的边界,组织需要提供共享信息、独立验证和专业支持。让每个岗位都使用 AI,并不会自然形成 AI Native 组织。本文所说的 AI Native 组织,是指根据人和 AI 各自的能力,重新安排信息路径、责任和协作方式。

                                                                                                                一种可行的组织方式,是建立围绕业务结果的小型交付单元,同时提供组织级的共享上下文、工程平台和专业支持。交付单元可以由超级个体或少量跨职能成员组成,从目标定义到实现、验证和运行结果持续负责。这样,知识、执行过程和验证证据无须随着岗位切换而反复转述。

                                                                                                                图 6:AI Native 交付单元与研发平台的共同工作基础

                                                                                                                以退款需求为例,交付单元直接确认用户目标,支付专家只在关键规则上参与,平台则提供支付渠道契约、异常测试和灰度观测。这样,专业人员可以同时服务多个交付单元,无须成为每项需求都必须经过的固定传话站。

                                                                                                                要让这种方式真正运转,交付单元的责任必须与权限相匹配。单元需要能够查证业务事实、调整需求范围、调用必要工具,并在证据不足时停止交付。涉及多个系统的共同规则由统一契约维护,专业复核根据风险介入,同时还要明确由谁维护全局一致性。

                                                                                                                人和 AI 还需要在共享状态中协作。每项任务使用了哪些资料、依据哪个版本、留下哪些假设、完成哪些检查,都应清楚可见。如果只是把多个岗位各自的聊天窗口串联起来,摘要交接和语境丢失仍会出现,增加 agent 数量也无法消除这些信息损耗。

                                                                                                                因此,组织协作应围绕“目标、约束、变更、验证证据和运行结果”展开。人的工作重心随之转向业务取舍、系统设计、独立判断和例外处理,AI 则承担经过授权的信息搜集、常规内容生成、任务执行和检查工作。专业分工仍然存在,但固定的岗位接力链可以缩短。

                                                                                                                04

                                                                                                                面向 AI 的研发平台:自动化流程如何转化为交付效率

                                                                                                                超级个体可以减少交接,却仍受个人理解和验证能力限制。研发平台要把需求资料、验证依据和运行反馈沉淀为团队共享能力,减少重复解释、检查和协调的成本。

                                                                                                                4.1 AI 核心问题是有效信息不足,可靠验证跟不上生成

                                                                                                                平台需要回答三个问题:关键约束怎样进入实现,生成结果凭什么可以接受,运行结果怎样返回需求判断。流程能够自动执行,不代表这些问题已经解决。

                                                                                                                在需求侧,平台要让事实、契约、决策和未决事项可追溯、可复用;在验证侧,平台要提供独立证据,减少人理解和检查陌生代码的负担;在运行阶段,平台还要把业务反馈带回原始需求。只有信息获取、人工核验和反馈等待的成本下降,平台才能产生端到端交付收益。

                                                                                                                因此,平台应围绕一次可追溯的变更组织信息:目标是什么,使用哪个版本的约束,修改了哪里,哪些检查已经通过,还有哪些未知,运行结果怎样。agent 和对话可以更换,这些依据必须持续保留。

                                                                                                                4.2 Agent 流程串联的效率收益与信息边界

                                                                                                                这里讨论的研发平台,是把 Claude Code 等可远端运行的 coding agent 部署在开发环境中。用户在平台上提交任务、提供上下文,或通过 chat 与 agent 协作;agent 在远端读取项目、修改代码、运行命令和检查,再把变更提交到 Git 仓库,进入后续 CI/CD 流程。平台还可以通过连接器,让 agent 访问需求、代码托管、测试和发布等外部系统。

                                                                                                                这种平台把原本分散的操作串成一条工作流。它可以统一准备开发环境、分配和并行执行任务、记录上下文与操作过程,并自动衔接代码评审、测试、合并和发布,从而减少环境准备、人工转述、重复操作和阶段间等待。

                                                                                                                工作流连通不等于交付质量得到保证。如果多个 agent 只依赖上一步传来的摘要,岗位接力只是变成了 agent 之间的摘要接力。源头没有确认的规则仍会被猜测,已经遗漏的约束无法靠后续加工恢复,多个 agent 还可能共享同一个错误假设。以退款需求为例,如果团队没有明确重试是否沿用同一个退款标识,实现 agent 可能选择默认方案,测试 agent 再根据这份实现生成能够通过的用例。流程执行成功,仍不能证明系统不会重复退款。

                                                                                                                平台与 coding agent 应有清楚的能力边界。平台作为控制与证据层,负责身份权限、远端环境、任务状态、资料版本、质量门禁、审计记录和流程推进;coding agent 作为可替换的执行单元,负责理解任务、修改代码、调用工具和返回结果。这样既能使用 agent 已有的 chat、项目理解和工具调用能力,也能避免平台重复建设一套智能执行能力,制造新的信息转述层。

                                                                                                                模型能力提高后,agent 对需求和代码的理解、任务规划、工具调用与代码生成通常也会改善,平台会直接获得这部分收益。但平台仍要解决需求信息、执行环境、权限、验证证据和运行反馈如何共同支持可靠交付的问题。因此,研发平台的提效上限不等于 coding agent 的能力上限:前者取决于端到端交付系统,后者主要影响具体任务的执行效果。

                                                                                                                4.3 平台的核心工作:关联事实、执行、验证与反馈

                                                                                                                研发平台无法代替团队确认所有业务事实,但可以让每次变更依据了哪些事实、执行了哪些操作、通过了哪些检查、产生了什么运行结果都能够追溯,并根据这些证据决定流程能否继续推进。

                                                                                                                图 7:以共享上下文和独立证据约束自动化研发流程

                                                                                                                这些能力可以复用代码仓库、需求系统、CI 和观测工具,再通过标准接口提供给 agent。规则和操作可以封装成指令或技能,但关键检查与权限边界必须由执行系统落实,不能只要求模型“记得遵守”。

                                                                                                                流程是否继续推进,应由证据决定。约束得到确认后才能据此实现,必要检查通过后才能进入相应的发布范围。检查失败时,应保留原始结果,补充规格或修改实现后重新检查;生成者不能自行忽略未通过的检查。测试通过只代表已经定义的判据得到满足,尚未覆盖的风险仍要明确记录。

                                                                                                                退款功能上线后,团队还要确认实际到账等待和客服求助是否改善。代码可以回滚,却无法撤回已经发生的退款,因此业务恢复必须单独设计。只有把技术结果与业务结果关联起来,平台才能把运行证据带回需求判断,并减少信息在返工过程中的反复流转。

                                                                                                                4.4 建设顺序:先扩充证据,再扩充自动执行范围

                                                                                                                平台建设可以从一种反复出现、边界可控的真实变更开始,以成熟 agent 作为执行入口。团队应整理关键契约、决策和历史故障,明确资料责任人;同时记录澄清、生成、验证、等待和返工耗时,找出真正的交付瓶颈。

                                                                                                                资料能够稳定使用后,再把验收依据转成可执行检查,让 agent 直接取证、执行和返回结果。需求、代码变更、检查结果和运行证据建立关联后,平台才能逐步自动推进流程。现有能力应直接接入,避免另建信息孤岛。

                                                                                                                当证据链能够稳定支持交付决定时,平台才适合扩大并行执行和预先授权的范围。团队需要预先明确三类边界:具备哪些证据后,agent 可以自动执行变更或进入下一环节;出现哪些异常时,必须交由相关负责人或相应人员处理;缺少哪些关键信息或面临哪些风险时,平台必须停止变更。

                                                                                                                如果等待验证的变更已经形成积压,就应限制新增任务,避免继续增加 agent,使更多未经验证的代码进入队列。

                                                                                                                每次扩大自动化范围,都要比较同类任务在相同质量要求下的端到端结果,并计入知识维护、平台运维和专业复核成本。共享资料应减少重复解释,自动检查应减少人工核验;如果这两项成本没有下降,自动化只是把工作转移到了平台维护和异常处理。

                                                                                                                4.5 人退出交付关键路径的条件与边界

                                                                                                                只要每次交付都需要人重新理解系统、逐项确认风险并处理未知情况,人的判断能力就仍然限制交付速度。把操作交给 AI,不会自动消除这项限制。

                                                                                                                责任归属和操作瓶颈需要分开判断。人可以继续承担结果责任,同时通过预先授权、自动检查和例外处理退出常规确认。责任仍在人身上,并不意味着每次交付都要等待人工操作。

                                                                                                                人能否退出常规交付的关键路径,要根据系统持续运行的证据判断:

                                                                                                                这些条件可能先在边界明确的任务中成立。如果常规流程表面上已经自动完成,专家却需要频繁处理异常,说明工作只是被转移到了例外处理。只有计入这些异常和长期维护成本,才能判断人的瓶颈是否真正移走。

                                                                                                                这个临界点要用运行结果检验,不能根据一次能力演示推算兑现时间。平台应逐步扩大已经验证的自动化范围,同时保留识别未知约束、升级处理和安全停止的能力。

                                                                                                                4.6 研发平台的提效应以端到端交付结果衡量

                                                                                                                研发平台可以把提效范围从编码扩展到资料获取、检查、集成和发布,端到端收益因此可能高于只使用 coding agent 的局部收益。但阿姆达尔约束仍然成立:只要需求确认、人工验证或运行反馈仍是最慢环节,整体效率就不会按编码速度同比提高。

                                                                                                                平台能够自动推进多少工作,取决于任务是否容易明确和验证,以及现有证据能够覆盖多大范围。模型能力提高会改善 agent 的执行效果,平台也会从中受益;但它不会自动补齐业务事实、扩大验证容量或加快真实反馈。平台的提效上限与 coding agent 的能力上限并不相同。

                                                                                                                判断平台是否真正提效,应比较质量要求不变时的端到端交付时间、人工判断和返工成本、上线缺陷与长期维护成本。平台建设的目标,是通过共享可靠信息、独立验证和运行反馈,逐步扩大能够安全自动执行的范围,而不是增加代码产量或 agent 数量。

                                                                                                                05

                                                                                                                结语 把代码生成速度转化为交付能力

                                                                                                                Vibe coding 改变了软件开发的成本结构,却没有消除需求确认、系统取舍、独立验证和运行反馈。它能更快地把已明确的要求转成代码,但端到端的交付效率,仍取决于业务目标和系统约束能否被充分理解,以及实现结果能否得到可靠验证。

                                                                                                                因此,衡量提效的标准,是在质量要求不变的情况下,需求能否更快、更稳定地转化为真实可用的结果。任务越明确、证据越充分,生成速度越容易转化为交付速度;系统越复杂,越需要超级个体、小型交付团队、专业人员和研发平台共同维持目标、约束与责任的连续性,把局部的编码提速转化为整体的交付能力。

                                                                                                                基于这些实践,我认为,走向成熟的 AI Native 研发,应当让人的判断、AI 的能力与持续积累的知识和经验不断融合、形成合力,使研发组织在保障可靠交付的同时,更快地探索业务机会、验证创新,并在这一过程中积累持续演进的组织能力。

                                                                                                                -End-

                                                                                                                原创作者|李晓鹏

                                                                                                                感谢你读到这里,不如关注一下?👇

                                                                                                                图片

                                                                                                                📢📢来抢开发者限席名额!点击下方图片直达👇

                                                                                                                扫码领取腾讯云开发者专属服务器代金券!

                                                                                                                图片

                                                                                                                跳转微信打开

                                                                                                                一个人用AI像开挂,团队协作就打架?问题不在工具,在组织

                                                                                                                2026年10月29日 08:45

                                                                                                                原创 王晓波 2026-10-29 08:45 广东

                                                                                                                关注腾讯云开发者,一手技术干货提前解锁👇

                                                                                                                开发者公众号专属群聊

                                                                                                                扫码加入获取更多一手教程、科技前沿报告

                                                                                                                 引言

                                                                                                                这场分享来自一个已经跑了两年的真实实验场:一支千人规模的研发团队,把不同的 AI 编程路线分给不同的小队去打样,再把撞到的墙一一记录下来。王晓波从「代码生产不再稀缺」这个起点讲起,复盘了老城改造、精益流程、全民造物这三条被大多数团队采用的路线各自走到的天花板;接着指向一个被普遍忽略的结构性错配——编码只占整个研发过程的 30%,而几乎所有的 AI 投入都压在这 30% 上;最后给出他们正在试验的第四条路:把项目事实从人脑里抽出来做成可共享的上下文,用企业本体描述统一的业务语义,让组织围绕 Agent 重新分配执行、验证与责任。

                                                                                                                 作者介绍

                                                                                                                王晓波,嘀嗒出行CEO、腾讯云 TVP、腾讯云架构师技术同盟活动组织主席,管理一支千人规模的研发团队。过去两年,他把这支团队拆成多个小队,分别按不同路线打样 AI 编程落地,并在此基础上设计了一套面向企业的 AI Native 研发体系。

                                                                                                                 前言

                                                                                                                这两年 AI 编程引发了一系列的故事,我们也做了很多实验,尝试了很多路线,也总结了一些情况。我不敢说这些结论都是对的,因为这件事本身大家还都在各自的讨论和探索之中,我今天讲的是我们实验出来的经验和一些新的想法。

                                                                                                                今天的分享大致分四段。第一段先回顾 AI Coding 这几年到底发生了什么,为什么到了 2026 年所有程序员都开始焦虑。第二段是我们实际走过的三条路——老城改造、精益流程、全民造物,每一条都有故事,也每一条都撞到了自己的天花板。第三段是今天的重点,我们为什么认为问题不在工具而在组织,以及我们正在试验的第四条路是怎么设计出来的。最后一段聊聊我对软件工业化这件事的判断,以及程序员这个职业接下来会变成什么样。

                                                                                                                01

                                                                                                                代码生产突然不稀缺了

                                                                                                                1.1 从补全工具到生产主力

                                                                                                                我们先回顾一下整个 AI Coding 的过程。早期我们一直是拿它来做补全,或者把它当成一个文具。到 2024 年的时候,感觉这件事情在大部分情况下已经可以用于生产了;到 2025 年,基本上大家都在用于生产。特别是 2026 年开始,如果一个团队还没有开始 AI Coding,这个团队几乎就要被淘汰了。也是在 2026 年,几乎所有程序员都开始焦虑:会不会被替代,未来会怎么样。

                                                                                                                如果只着眼于程序员这一个职业,我把这件事总结下来,其实就发生了一件事——我们的代码生产突然变得不稀缺了。往前倒数十年二十年,程序员一直是比较稀缺的职位,所有公司不管大小厂都在疯狂地招程序员,特别是好程序员。以至于大学的计算机专业开始非常红火,超过了原来好多的热门专业,好像读了计算机就业就不愁,大厂百万年薪几乎成了程序员的一个标签。

                                                                                                                对我触动最大的是什么?我发现 HR 同学、行政同学开始用很多工具做自己的小系统,并且很能用。那一刻我的第一反应是:程序员对代码的这种独有性、稀缺性,正在消失,或者即将消失。

                                                                                                                1.2 兴奋、醒悟、回头一看:一年里的三段情绪

                                                                                                                我们也是在这个时候开始做一些实践的,实践过程中发现了一个很有意思的情绪曲线。年初的时候,大家都很兴奋,说我的工作可以交给 AI 去完成了,反正交给 AI 做,我还能歇会儿。到了三四月份,大部分程序员突然醒悟过来:好像我的存在价值出问题了。到了五六月份,又有新的问题冒出来——原来那些被快速生成的代码,我们回头去看的时候发现一件非常麻烦的事:我们一直说的「屎山代码」,生成完这些东西之后可能变得更屎山了。

                                                                                                                第二个更大的问题也出现了。每个程序员都在说,我消耗了大量 token 在生成代码。但我们从整体上去看的时候,一个很大的问题出现了:整体提效有限,甚至有些团队没有提效,甚至有些同学出现了混乱的状态。

                                                                                                                1.3 几个真实的、有点荒谬的现场

                                                                                                                举一个例子。我们看到一个非常奇怪的场景:产品经理写 PRD 的时候用 AI 帮他补全,把 PPT 做完,然后把这份由 AI 生成的 PRD 丢给程序员,程序员再喂给编码 Agent 去写代码。这个时候,信息的失真就开始出现了——前一段的 AI 幻觉,被后一段的 AI 当作事实继续往下推。

                                                                                                                还有一个真实现象。一开始我们的 Leader 们定了一条规矩:用 AI 生成的代码,必须全部 Review 完才能上线,不然不允许上线。跑了一段之后就发现,AI 生成的代码根本看不过来,于是算了,直接上,不再全部 Review。质量的可控性就是从这里开始变化的。

                                                                                                                更有画面感的是这个。我看见一个程序员在那儿坐着,我问他你在等什么,他说我在等 AI 把 token 吐出来,他吐 token 太慢了。程序员的工作状态跟原来完全相反了——原来是把所有东西准备好之后开始专心写代码,现在是把东西喂给 AI 之后不停地停顿、等待。

                                                                                                                从顶层视角来看,整个过程好像并没有很好地提效。但对于个人来说,好像我的能力又上去了。这个矛盾,就是我们后面所有实验的起点。

                                                                                                                02

                                                                                                                我们走过的三条路,每一条都有自己的天花板

                                                                                                                我把这两年的所有情况总结完之后,发现到目前为止我们走了三条路,这三条路分别带来了不同的结果和不同的现象。因为大家都不知道到底怎么是对的,我这边研发差不多有一千多人,我就把它分成好多团队,让不同的团队去打样不同的方式。

                                                                                                                2.1 第一条路:老城改造

                                                                                                                这条路可能是目前社会面上大部分团队都在采用的办法:给每个程序员、每个产品经理都配上一个 Agent,然后他开始工作。但整个项目管理流还是老的——从产品到研发到测试到上线,这一整套过程还是照样走完,只是在中间给每个人、每个环节加上一定的知识库,配上一个 Agent 和 token。

                                                                                                                具体走下来是这样的:业务提出需求,产品同学开始用 AI 补足初稿,生成交互稿、补全 PRD 里的内容。但到了排期这一块,因为是排给人头的,大部分没有办法让 AI 真的去排,所以大部分 Leader 就变成了排期工程师,把任务往下拆。到了编码这一段,是大家全员 All in 的地方,一定要用代码生成,以至于我们把工程项目一遍一遍地拉出来上传,让 AI 去读懂再去写代码。

                                                                                                                测试这一块的变化最出人意料。一开始我们也认为测试团队可以用 AI 去测试了,但跑了一段之后发现:在 AI 生成的过程之中,测试反而更重要了,因为不确定因素更大,我无法真正去信任 AI 做的东西是不是对的。最后测试团队几乎变成了一个「烧香」的团队——上线质量的最后一道畏惧感,全部交给了测试团队,但依然很凌乱。

                                                                                                                这条线上我们做了很多事,主要是围绕知识库来做的。因为产品同学要设计整个产品,需要知道系统的运行状态和代码状态,所以我们开始把代码抽象成代码知识图谱,供上层的人调取历史知识,再结合 AI 去做初稿。这件事看起来是可以的,大家也都很兴奋,因为原来需要人脑工作的部分,突然变成了我去打提示词,甚至是喂给它一个目标,它用一个 loop 去完成,听起来很美。

                                                                                                                但这条路上我们碰到的最大问题在于:它是单点提效。程序员把自己的效率提得很高,代码 90% 都是 AI 生成的,但为什么我一天还是只做了这么多?产品同学说我的交互稿已经用 AI 做了,但为什么我的工作也没少,甚至多出来一些工作?对程序员来说更别扭——我原来不需要 Review 这么多代码,但因为不放心,反而要看更多的代码,而 AI 吐 token 很快,成千成千行代码生成的时候,人是看不过来的。

                                                                                                                知识库这条线也有自己的问题。原来系统做了微服务架构之后,代码知识图谱其实扫不全,因为系统之间是隔离的,还要联动很多基础设施建设。知识本身的偏差也很大,大模型本身的幻觉不小,如果我们把一个不靠谱的业务知识库放进去,等于是在放大它的幻觉面。

                                                                                                                最后我们看到的结果是:生成的自动化很多,但整体提效反而变差了,项目一致性和质量开始下降,判断力全部取决于个人。原来那些确实高级的程序员,他的能力确实被放大了;而很多中低级程序员,能力并没有被真正放大,是一种假象的放大——他能产出很多,但产出质量很差,因为他没有办法完整地描述 AI 所需要的知识。超级个体被放大得很厉害,弱一点的个体好像变得很无用,而整体效果并没有真正提上来。

                                                                                                                2.2 第二条路:精益流程,把工作切成知识块

                                                                                                                第二条路是在第一条的基础上做了一次精密加工。我们想,为什么我一定要用原来的流程?我是不是可以把产品经理和整个研发测试的边界打破,把一些工作抽象出来?我们有一个团队去深度尝试了这件事,把业务抽象成很多我们称之为「node」的单元,里面包含业务块上的知识,包含为这个业务块整理好的上下文,然后让 AI 去跑,去更自动化地生成。

                                                                                                                比如机票下单这样一件事,我能不能把「出一张机票」完整做成一个工作知识包,让 AI Coding 的时候有足够的知识来支撑它?一开始我们觉得挺好的,这个工作知识包一旦完善,生产效率确实不错。

                                                                                                                但随着使用时间推长,一个大缺点出现了:我们似乎在做一件穷举的事情。我们想把工作中每一个小块都切成一个独立小块,配上知识,让 AI 去自动化。一开始收益大,是因为原来完全没有。后来我们发现这些东西开始爆炸,复用性极低——知识包做好之后,下一件事情来的时候它好像大量不匹配,我要去改它,甚至要重新生成另一个知识块。这些块大量不可复用,甚至你都不敢复用,因为这是别人做完的,你拿过来使用的时候,不能保证里面写的是对的还是错的。

                                                                                                                今天我们看到很多 Agent 里面的技能市场也是一样的情况:大量的技能充实了所有东西,但你用的时候,能完全放心地不改就用吗?你也不知道它里面到底是错的还是对的。而且很多技能上个星期还有用,下个星期场景一变,可能 80% 就错了,哪怕只错 20%,它的复用性也没有了。

                                                                                                                于是这些知识块出现了爆炸,最后变成了一堆电子垃圾。之前好像是在积累,但每次新的事情我又要重新做一遍。业务场景的变化是很大的,本质上我无法把未来可能碰到的问题全部穷举出来,指望未来某个业务来的时候,我调一堆技能、调一堆知识块就把它完成了——这件事不现实。

                                                                                                                还有第二个问题:当前企业 IT 系统里有大量变化中的数据,这些变化中的数据无法进入这样的知识块里去,所以信息链路还是打不通。最后导致大量的技能、大量的知识块重复、无序、碎片化,依然没有办法从一个顶层视角看到整个企业的知识链路是什么样的。这件事依然无法提效。

                                                                                                                2.3 第三条路:全民造物,然后信息孤岛回来了

                                                                                                                第三件事是我们一开始最兴奋的一件事——全民造物。我们做了一些简易的编程工具给到业务同学,他们发现自己可以去做系统了。最兴奋的先是产品同学,他说我可以自己去做了,不用再跟你唠叨半天。结果发现,他们写完的代码没人敢上线,因为没人敢背这个锅——代码上线了,出了故障谁负责?

                                                                                                                其次最兴奋的是业务同学:我们终于可以不用等你们排期了,不用提一个需求等你们响应半天、跟你们聊半天你们还听不懂,我们可以自己干。一开始确实做得非常好,我们有几个小的独立业务板块做出了很不错的东西。

                                                                                                                我举一个例子。我们有一家航空公司,他们有一个车队,负责接送飞行员上下班。这个车队原来基本上是学历不太高的同学在做,按照一张 Excel 表或者打个电话去接人。他们很想要一套类似滴滴打车那样的调度软件,能在 App 上用。但这件事的需求等级不会太高,这家航空公司的 IT 部门是不可能去响应这个需求的。后来这个团队跟着 IT 部门学会了 AI 编程,在他们自己的努力之下,用我们的 Agent 工具终于做出了一个简易版:能通过网页下单,司机能接单,能把这些车调度起来。这件事对他们来说很兴奋,我们也看过这套系统,后来也让它上线了。

                                                                                                                一个完全没有任何产研同学参与的系统被上线了、被用起来了,我们一开始也非常兴奋,认为这条路效率可能更高,于是开始小范围推广这种方式:让业务同学自己做自己的工具。行政同学、HR 同学、各种车队,都做了一大堆。系统从一个很完美的状态,终于进入到了一个爆炸的状态,整个系统数量翻了好几倍。

                                                                                                                可用性差这些其实不是最大的问题。真正大的问题是:每个系统出现之后,它们之间没有联动性,也没有联通性,也没有被设计过。同一件事情在不同系统里的表述是不一样的——有一个团队把一个 ID 叫做「订单 ID」,但它事实上可能是个手机号;另一个团队的「订单 ID」可能是个工号。等到这些系统想要做部门与部门之间的联动的时候,根本联不起来。

                                                                                                                所以我们没有把生产力极大释放、让大家都更好地信息化,反而做出了一个反向效果:重新回到了十年前的信息孤岛状态。在这件事上我们的反思是——对于一些系统紧缺的地方,这条路可以快速做出一些 IT 系统;但如果没有治理,它会成为一个反效果,甚至催生新的信息孤岛,让效能和管理的混乱一起出现。

                                                                                                                2.4 三条路的共同困境:三个问题没有人能回答

                                                                                                                我们把三条路放在一起总结,发现它们其实都卡在同样的三件事上:谁知道当前事实、谁持续组织下一步、谁对结果和生效负责。

                                                                                                                真正需要的变化,不是一个更强的编程工具,不是一个能让非程序员编程的工具,也不是一个更强大的 Agent 或者更强大的基模。哪怕这些东西再强大,它依然没有办法回答这三个问题。

                                                                                                                我们想清楚的是:需要做的是对组织的改变,以及对如何描述事实的改变。原来的研发体系里,大量的项目事实掌握在人的脑子里、在人与人的管理过程中,它并没有被数字化,甚至没有被知识化。当 AI 编程起来之后,我们需要把这些项目事实做成人和机器可以同步的东西,需要把整个组织的执行、验证、结果沉淀有效地组织起来,让它变成一个闭环。

                                                                                                                03

                                                                                                                效率提不上去的真正原因:30% 和 70% 的错配

                                                                                                                3.1 编码只占三成,我们把所有力气都用在这三成上

                                                                                                                我们再往下分析,为什么现在的效率提不上去。在整个开发过程中,比例可能每个团队有所不同,但我调查了其他一些团队,也看了自己的团队,真正的编码过程大概只占整件事 30% 左右的时间。

                                                                                                                剩下的时间在做什么?需求的澄清。大量的开会,大量的人与人之间的博弈,多人会议,整个过程中来回倒腾,甚至到了开发阶段还被返工、走不通的情况也经常出现。

                                                                                                                信息在传递过程中的损耗也非常大。业务从一个想法提出诉求,产品接到的时候第一步设计可能就已经错了,但这个错误的设计依然被往下推,到最后准备上线了才发现不是我要的,这种返工大概在 10% 左右。技术方案也是一样,A 说要这么做,B 说要那么做,C 说你不对;系统联调集成的时候,两边都说「你应该开个接口给我」,互相之间也在大量沟通。测试返工率也极大,部署环节同样有问题。

                                                                                                                问题就在这里:今天我们大量的 AI Coding,把重心全部放在了前面那 30% 上。所以我这边好的团队能到 30% 多的提效,差的在 20% 多,更差的就不好意思说了,甚至是没有提效的。我们把大量精力全放在编码这一段——生成代码的知识库、智能测试、各种运维分析助手,一堆东西。但这些东西全部以个体的人为单位去走,从来没有以团队为单位去走。

                                                                                                                3.2 每个岗位都有 AI,但这些 AI 互不相通

                                                                                                                在整个需求成型过程中,每个岗位都在用 AI,但这些 AI 又是不通的。明明在需求提出阶段就可以得到验证的问题,依然被流到了产品阶段;在产品阶段就可以判断出来是否能实现的东西,依然被流转到了系统设计阶段。每一次传递之后,信息的失真越来越大。知识在传递过程中必然衰减和变化,这种情况大量出现之后,它肯定不会超过一倍的提效。

                                                                                                                我也跟外面很多团队交流过,发现大家都没有说出现了倍级的效能提升。这是一个普遍现象,不是某一家的问题。

                                                                                                                3.3 从「以人为中心」到「以 AI 为中心」

                                                                                                                在总结的过程中我们发现一件事:原来整个研发过程、整个产研过程,其实一直是以人为中心的。所有的知识传递都是人与人之间完成的,人催人把工期往前推,人自己完成整个项目。虽然里面有大量协作,但都是人跟人的协作,每个人都有自己的上下文、自己的故事、自己的技能、自己手上的能力,和自己大脑里的所有项目事实。

                                                                                                                所以传统模式下我们更多的是在管理人。我们需要大量有能力的人,需要大量的开发规约,甚至需要沟通的标准、会议的记录。这一系列东西本质上都是为了以人为中心,让人和人之间能把知识传递起来,让一堆人有效协作去完成一件事。

                                                                                                                当我们开始用 AI 工具的时候,就发现要做的是打破以人为中心,转向以 AI 为中心。当一件事交给 AI 的时候,我需要的是给它补足上下文、补足知识、补足执行结果的验证,这一系列过程都需要以 AI 为中心去组织。

                                                                                                                这件事怎么理解?我们一直说 OPC(一人公司)好像很好用,甚至说一人部门也很好用。但在现实里,虽然大量 OPC 成立了,我们这些企业、这些大团队好像也没有少几个人,还是每个部门在协作。我们的理想和事实之间发生了一丝位移——大量的 OPC、OPC 部门,并没有在企业里大量出现;企业里出现的是什么?每个部门、每个岗位、每个人都在用 AI,而这些 AI 都是独立的,每个人都是自己独立的工具、独立的知识库、独立的上下文。

                                                                                                                所以我们需要做的,是让人与人之间、岗位与岗位之间的协作关系能够上下文打通,让 10 个人、7 个人围绕着同一个 AI,去补足它在执行过程中需要的知识,并且在需要人判断的点上做出有效判断。这可能就是把前面三条走不太通的路走通的出发点。

                                                                                                                04

                                                                                                                第四条路:把项目事实抽出来,让组织围着它转

                                                                                                                于是我们开始走第四条路。程序员喜欢造轮子,我们就造了一套比较庞大的体系,目标很简单:让一个企业能够整体进入 AI 化的状态,让研发这件事变得更快,让倍增的效能出现。

                                                                                                                ▲ 企业级 AI Native 研发体系总体架构:从业务变化入口到企业本体层的四层设计

                                                                                                                4.1 一个人用 AI 很顺,多人协作就坑爹了

                                                                                                                先说清楚这件事的难点在哪里。如果一件事就一个人做,他的上下文工程是非常好做的——他驱动一个 AI,知识工具、编码工具、管理工具都围绕他自己来,这事很容易完成。这也是为什么大家都觉得 OPC 好,因为一个人自然就贯穿了。

                                                                                                                当我们多人去做的时候,坑爹的事情就出来了:这个项目事实如何转化成需求、方案、架构、测试等一系列一致的目标?而且这个目标还在不停被细化,每个部门都在往里加自己的东西。要想在团队级提效,我们需要让人能对多个项目事实负责。

                                                                                                                顺着这个想,我们再追问一句:在 AI 编程的过程中,人到底是什么?我们每个程序员去让 AI 编程的时候,到底在编什么?让它去完善一个文档的时候,我们到底在写文档吗?其实本质上代码不是我写的,文档也不是我写的,是 AI 帮我写成的。但为什么它能写成?因为我喂给了它上下文,并且我给它做了目标确认和关键决策。

                                                                                                                既然一个人用的时候是这样,那么如何让团队所有人在同一件事上协作起来?协作需要的,是把人工确认和责任边界的决策合理分配到每个人身上,让不同的人在这个流程里对项目事实做确认、判断和验收。这就是第四条路的设计原点。

                                                                                                                4.2 先把知识和事实链沉下来

                                                                                                                第一件事,我们需要把整个研发流程做一次打包。既然要让开发过程的知识储备完善,我们就得把代码的链路知识读出来,把每个岗位、每个角色到底做了什么、到底问了 AI 什么、到底完善了什么,全部落下来。于是我们做了一个文件包,里面包含这件事上每个团队做了什么、需要什么的知识储备;另外把整个代码的状态也抽象出来,做成一个代码知识包。

                                                                                                                第二个是事实链。从需求到提案到任务,每个过程中每个角色在完成什么,把这条链圈出来:这件事上一环是什么角色,谁确认的,谁来告诉我们这是对的。把这条确认链路建立起来之后,我们才第一次对一个团队、一件事情有了统一的上下文。流程的控制也一并管起来。

                                                                                                                至于 Agent 本身怎么做,我们一开始当然是想自己做的,后来发现要完成一个 Harness 工程,做得最好的其实是模型厂商自己。于是我们把自己变成一个调度器:你可以是 Codex,可以是 CodeBuddy,也可以是其他编码 Agent,只要能被我这套体系调度。我们不做编程的 AI Engine,只做编程的调度者,去调度这些编码 Agent 完成工作,完成之后把交付物重新写回知识包里去。

                                                                                                                研发流程本身也重新定义了:从需求池开始,到每个阶段生成必要的文档,全部沉下去;再做自动的任务拆分,鉴定哪些任务适合自动化、哪些需要人工;人工的部分卡在哪个点上做门禁或者人工确认,也一并定清楚。

                                                                                                                4.3 只做产研自动化是不够的

                                                                                                                当我们把这套系统做完之后,依然发现有问题。因为我们完成的只是产研的自动化,而一个企业不只有产研——产研是个服务者,它服务的是整家企业的业务运营过程。

                                                                                                                当只有产研自己在做所谓的 AI 化时,你永远做不到位,因为你的知识不全,业务目标不全,运营过程也不全。大量的运营团队、行政管理团队、商务团队的实时状态你并没有掌握,不可能在你的产研流程知识里有任何体现。这些没有体现,你的目标就有可能是错的,你做出来的东西就有可能不是人家需要的。

                                                                                                                所以我们才去做下一件事:试图把整个公司做一个数字的投影出来。

                                                                                                                4.4 企业本体:一个 80 年代的老东西

                                                                                                                我们找了好多工具、好多想法,后来发现可能 80 年代那本《本体论》还行。本体论这件事本身不是在 AI Coding 这个时代诞生的,它诞生得更早。一开始所有程序员都觉得这不就是面向对象吗?仔细去看的时候,它确实是用一套比较好的描述方式把整个关系描述出来了——每一个业务的节点、模板、业务规则、动作,都可以被描述出来。

                                                                                                                我们也看到了 Palantir,他们说自己的本体很好,但不开源。我们去想,为什么他们这件事做了十年,这两年才开始比较红火?因为如果没有 AI 的帮助,建本体这件事好像不是人类能完成的——做出来往往不好,或者很慢,也不够及时更新。于是我们先用模型让整家公司的本体生成出来。

                                                                                                                放进去之后依然有问题。我们一开始把静态的本体模型做完,发现运行过程中的一些变化数据并没有在这个模型里,产研过程依然感知不到问题。特别是在处理 Bug 的时候,比如说现在有两个订单是错的,本体模型里根本没有这个时刻的状态,它如何去修复?

                                                                                                                所以我们需要把本体模型跟线上跑的系统、跟产研过程结合起来:让企业用本体模型定义出来的知识,能跟系统的代码块绑定,甚至跟正在开发过程中的任务做绑定,把 ABox 这样的东西做成一个可查的东西。这里面再展开就很大了,涉及到 ABox 要不要物化的问题,今天先不展开。

                                                                                                                最后我们把本体抽象成四种东西:TBox、ABox,加上规则(Rule)和动作(Action)。规范好之后,它就变成了一套统一语义,可以用来描述公司当前的状态——从客户到订单到审批,这是一条什么样的关系链路,链路上有什么规则,每个点上有什么业务动作,这个业务动作背后是哪一个 IT 系统在完成。这些知识被有效组织在本体里,我们就可以在新的工作过程中,统一地从这里拿到整个企业的业务语义和知识。

                                                                                                                这件事带来的直接好处是:一个不靠谱的需求,明明不可实现,我们在本体里推演一把,就已经能判断出来你这个根本没法做,或者你打破的流程太多、这个流程根本就不通。它在最初那一端就被消灭掉了。

                                                                                                                4.5 把「为什么要做这件事」管起来

                                                                                                                本体做完之后还有问题:你的业务入口、你的系统变化入口,其实并不被你所锁定。历史上所有的研发人员都没有锁定过这个入口——为什么要做这件事?老板想做,老板开了个会想做;市场变化了想做;某个竞争对手在做;甚至是「隔壁楼灯还没关,所以我们也别关」。变化点的根因从来没有被管理起来。

                                                                                                                所以我们把业务的变化点抽象出来。第一,既然有了这么多 AI 工具和知识,是不是可以让它主动发起——一些异常、一些趋势,它能不能主动发现并报出来,让人去响应。第二,衡量整个业务的变化信号:某个产品正在规划新东西,某个竞争对手在规划新东西,这样的知识能不能先响应到 AI 的知识库里,让大家发现它、使用它。第三,技术需求、生产故障、指标变化,这些也要能进来。

                                                                                                                这一切的前提是一套统一的业务变化语义定义:全公司说同一句话,说到订单那就都是同一个订单,订单变化就都叫订单变化;今天这个指标,所有人说的是同一个指标。说人话,不是说鬼话。

                                                                                                                把这几层全部打通之后,我们发现这件事好像能跑起来。目前在我们这里也没敢全推,因为感觉这玩意也是个实验品,到底行不行是未知数,不代表它一定行。我们在一个小的业务场景里让它闭环,目前是能跑起来的,跑起来之后也确实比原来要好一些。在这个基础上还可以做很多贯穿式的治理方案,比如整个风控权限、发布审计,包括 AI 过程中哪些做了哪些没做,也能有效地审计到。

                                                                                                                4.6 管理对象变了:从人和工期,到目标、上下文、依赖、证据链

                                                                                                                要把这件事做好,有一件事是必须做的:把业务目标和项目事实真的提取出来。原来这件事是人与人、口与口之间的传播,大家一直不会说太多,有很多猜测。有的时候我们说这个老板脑子比较好,或者说这哥们比较会拍老板,所以他想得比较对。但这套东西在 AI 里不会成立——你不把这些事情放到知识库里,就不可能让整个流程参与进来。

                                                                                                                第一个变化是管理对象。原来我们管的都是人:我手上有 10 个人、100 个人甚至 1000 个人,我管人的目的是让他把我的业务目标和项目事实按照我的想法落地。只要管好人,这个人能听得懂话,他就一定能把业务目标和项目事实往下传——这是我们原来管理的认知。任务工期也是对人管理:这个程序员比较好,三天干完;那个比较初级,没办法,只能让他六天干完。

                                                                                                                现在管理对象要变:把目标管起来,把上下文管起来,把依赖管起来。因为有大量 AI 参与,我还需要把证据留下来,不然我怎么知道它是对是错;剩下的是把责任定清楚。管理链从「人、任务、工期」,转变为「目标、上下文、依赖、证据链」。

                                                                                                                4.7 状态来源变了:从晨会汇报,到事实和证据

                                                                                                                第二个变化是状态来源——这件事现在进度到什么程度了?原来我们靠什么?靠会议、报表、靠问。早上开个晨会说我昨天完成什么样了。但我们每个程序员自己想一想,传统模式下做了几十年,我们报的进度真的是对的吗?我自己也是从写代码上来的,老实说大部分情况下进度就是瞎说的——「大概吧」「也许吧」,一层层的也许吧,一层层的大概吧。我说我已经完成 50% 了,难道后面还要花同样的时间完成另外 50%?不一定。可能一哆嗦几行代码,想到更好的算法就提前完成了。

                                                                                                                这件事原来是不可管理的,现在我们要把它变成可管理状态:从 AI 的生成结果和链路情况里去找,从事实、结果和证据链里去找,而不是从会议里去找。

                                                                                                                4.8 推进方式变了:从人催人,到事实驱动

                                                                                                                第三个变化是推进方式。原来我们能体会到的就是大家一直在被催:老板催 Leader,Leader 催程序员,高级的催低级的,几乎都是由人在推动。

                                                                                                                我们能不能把它变成一个由事实组织的判断逻辑——上一步的事实还没有完成,你如何进到下一步?AI 是不可能被催的。你骂它两句,它不会帮你把事情做完,它只会回答得客气一点。我们需要把这些事实验证完,让它进入下一步。

                                                                                                                4.9 人的边界变了:判断、阻塞、修复、越权

                                                                                                                最后一件事是重新定义人的边界。在这个过程中,每个岗位、每个人、每个角色到底还要做什么,哪些事情需要集中他的注意力?

                                                                                                                我们看下来主要是四类。第一类是判断,大量 AI 需要人去判断结果和执行过程的地方。第二类是依赖的阻塞,很多跨团队、跨外部的依赖在知识里不全,需要人去补足。第三类是验证失败之后如何去完善它。第四类是权限之外的意外情况。

                                                                                                                确定完这些之后,我们还需要在人与 Agent、多人与多 Agent 之间统一认知。这里我们直接沿用了业界开放的 OKF 协议,说实话这个协议也没规定什么,但至少比没有好。我们基于它做自己的知识包,把这件事描述清楚:哪些人在做,哪些层需要什么知识,变更是谁干的,有什么事、是谁确认的,这些事实依据都在这个包里产生。这样在同一件事的工作过程中,所有人对共享的知识对象就有了一个比较好的共享过程。

                                                                                                                传统系统都是把知识拆成字段——告诉你要调的接口有多少个字段、存的库表是什么样的。有了这套知识标准之后,我们比较好的一点是把完整的语义保留下来,让人与人之间能读取同一份互相都看得懂的知识。有了这份看得懂的知识之后,执行过程还是那一套目标管理方法:确定目标和范围,对每个任务依赖做执行,人在关键点判断,判断完之后把知识稳定下来。

                                                                                                                一个包往往是不够的,需要大家在一个空间里协作,所以我们把它凑成了一条工作空间,把知识包和其他流程规范、需要总体验证和拆解的东西放在一起,让这条线变成像流水线一样往前走。

                                                                                                                05

                                                                                                                体系跑起来之后:岗位在融合,效能第一次可被统计

                                                                                                                5.1 一个项目事实,两条链路,六条生产线

                                                                                                                我们拿一个实际的例子来看,假设要做一次会员优惠的活动规则升级。这件事不管是原来的人工团队,还是在人工流程上配合了 AI 编程之后的过程,它永远是散的——一个会员权益的变化,从支付开始到优惠发放到整个业务流程都会受到改动,牵涉多个系统、多个部门、多个角色。

                                                                                                                放到新的体系里会发生什么?当一个项目事实被定义出来之后,通过目标驱动和当前事实的判断,管理系统开始分派任务。根据企业本体的模型状态,它会走出两条链路,比如从权益的发放到权益的识别应用这两个圈分别往下走。人的判断出现在关键点上:技术负责人判断这件事到底应该放在哪里做,业务人确认这套方案的边界是对的吗、它真的能达到我们订单的理想状态吗。每个节点在真实的工作台上一步步告诉你,我失败了多少,验证了多少。

                                                                                                                换一个视角看,刚才那六个要改的点,就变成了六个 Engine 在跑。从人的视角来说,他看到的是六条生产线正在生产。对原来的程序员或者产品来说——因为他们的边界本身也融合得差不多了,检测和实现的事也分不太清了——他更多的是在看:一个人能同时操作几条流水线。

                                                                                                                ▲ AI 软件工厂的设想:多条 Agent 流水线持续生产,少数人只负责价值、异常、知识与验收

                                                                                                                5.2 岗位开始融合:研发在抢测试的活

                                                                                                                在这样的七个岗位状态下,我们需要一个过渡,把原来的工作方式迁移过去。我们想到的是两条流:一条是管理流怎么走,一条是 AI 执行流怎么走。这两条流理清之后,人在这两条流上要做什么就清楚了。

                                                                                                                ▲ 岗位边界随连接、执行与责任的重新分配而改变:专业责任仍由人承担

                                                                                                                更明显的现象是很多岗位开始融合了。有些业务岗、运营岗和产品岗开始分不清楚——产品可能把原来业务要做的事情做完了,运营可能把原来产品提出来的工作也做完了。

                                                                                                                特别明显的是测试团队和研发团队的融合。之前我们一直在想,测试这个团队未来是不是会消失、是不是会被 AI 替代。但事实的情况并不是 AI 把测试团队往死路上逼,反而是研发团队在抢测试团队的活,这件事其实很好玩。

                                                                                                                仔细想,这是个必然结果。原来对一个程序员来说,我把代码写完,自己跑一遍,就丢给测试去测,而测试的任务是把这哥们写的不靠谱的代码里的不靠谱的点找出来。但当 AI Coding 发生之后,你会发现一件很奇怪的事:这个代码不是你写的,是 AI 根据你给的知识生成之后交付给你的,这个时候你需要去验证 AI 写的是不是对的。于是驱动 AI 写代码的程序员本身,已经变成了测试。流转到测试环节的工作反而变少了,甚至应该反向融合——测试去做开发的事情,因为这两个角色好像没法分离了。

                                                                                                                5.3 架构的「秘方」被业界最佳实践替换掉了

                                                                                                                架构设计也在变。原来的架构,小厂有小厂的设计,大厂有大厂的设计,好团队有好团队的设计。在 AI 这个过程中,当你把事实描述清楚之后,因为基模本身是一个超大的知识库、超大的图书馆,它几乎拥有这个世界上已知的可公开知识的集合,它的最佳实践就可以被拿出来用。

                                                                                                                这件事的结果是:原来的一些秘方没有了。某些团队、某些公司原来有些自认为对的秘方,也许是不对的;自认为是最佳实践的东西,也许不是最佳实践。它们被一套相对公允的业界最佳实践给替换掉了。

                                                                                                                5.4 质量先降后升

                                                                                                                质量这件事也想说一下。原来大家一拥而上生成屎山代码的时候,质量确实发生了变化,是降低的。但随着大量规范化的团队配合使用之后,至少在打样的这个团队里,它的质量反而在变高,比人写的要好很多。

                                                                                                                5.5 效能第一次真正可被统计,而统计是为了下一轮

                                                                                                                交付管理也一样。原来靠人催人,现在变成了完全有依据。运行之后,我们可以去做一些计算交付效率的事情了。

                                                                                                                原来我们的研发效率其实是不太可统计的。虽然每家大厂小厂都声称自己对研发效能有很好的衡量标准,但平心而论,我们原来那些所谓的效能数据真的是对的吗?我认为可能很多是不对的。因为你是基于人的状态:今天这哥们能写这么多代码,明天他心情不好的时候还能写吗?这是个极端的案例,但还有更多的事情被打断、开会的效率、这件事是不是真的被做了,在传统的以人为中心的产研过程里,其实是不太可统计的。虽然最终大家都有一个值,说这个东西做了多少、消耗了多长时间、我们效能是人家的几倍,但这件事写 PPT 还可以,真要平心而论的时候,大家都是没那么自信的。

                                                                                                                真的把交付效率和 AI 结合起来之后,它是可统计的。因为你的澄清过程、编码过程、验证过程、返工过程、确认过程,本质上都被真实地记录下来了,底下有整个事实链。从项目开始到结束,整条链上的结果可以反向统计出来。

                                                                                                                大家会说,统计出来有什么意义?证明你更快,让老板多给你点活?其实不是。当你的效率真正被统计的时候,你才可以去做下一件事:让每一轮的交付为下一轮的变化做证据准备和知识储备。这样一次大的改动,在这里沉淀的效能数据和知识储备,是为下一次迭代能更快、更少人工决策和人工参与提供事实依据的。

                                                                                                                再回到一开始那个 30% 和 70% 的问题。30% 的编码工作大家现在都在用各种方式跑,而剩下那些人确认的事情原来是很散的。如果我们把它用流水线的方式管理起来,再问这个组织到底提效多少,理论上来说就是:你现在手上这帮人,能同时做多少条产线的人工确认、验证和判断,它就是多少倍的提效。

                                                                                                                我们的实验当然还在进行中。十倍也有点吓人,也没那么多,因为脑袋确实切换不过来。目前我看到的数据是倍增有了,但前面这个过程我们还在进一步细化,还比较粗,包括本体模型能不能体现出整个公司的投影也是个问题。初步看到的是它确实可以展望一下倍级的状态。

                                                                                                                所以我对研发效率提升这件事的判断是分层的:如果着眼于单个任务,提效就在一个很低的层面上;如果把整个项目作为提效结果,它会更上去一层;如果放到组织层——重新定义产品经理、程序员、测试甚至运营这些角色分工,让他们更多地融合——它又会再上一层。但组织层依然无法体现出整个企业的提效。只有当整个企业的业务目标、事实依据都进入这个体系,它才能达到最高的提效状态,那就是整个企业被 AI 化的状态。

                                                                                                                06

                                                                                                                软件工业化:八级钳工的蜕变

                                                                                                                6.1 改变的不是程序员,是生产关系

                                                                                                                我们以前一直有一个想法,说 AI Coding 改变了每个程序员。但从现实的实践过程来说,我觉得它改变的是整个软件生产的组织方式和生产关系。原来手工业的状态正在被工业化,软件正在被快速地工业化。在这个过程中,程序员这个手工业者的组织方式慢慢在退下去,工业化就会产生流水线,然后产生可持续的运营状态,工业化的标准也会慢慢出现。原来我们程序员引以为傲的、手上的技能,就开始蜕变了。

                                                                                                                ▲ 从手工作坊到自动化工厂:工业化的四个阶段,正在软件行业重演

                                                                                                                这张图我让 AI 画了好久才终于表示出来。看机械工业化的过程:最早是几个人在手工作坊里,用钻头、螺丝刀敲打着制造一个东西;慢慢出现了自动化生产工具,比如机床;再往后流水线出现;流水线之后是智能工厂。

                                                                                                                软件的情况也是一样,只是我们长时间停留在了第一个阶段。你看我们写代码之前,一帮人对着一个白板画所谓的架构图,这个场景跟手工作坊里几个人围着一张桌子商量怎么做,其实很像。为什么?因为长时间以来,写代码这件事没有被自动化,它一直是个手艺活。

                                                                                                                6.2 一个小朋友把「屎山代码」这个执念问破了

                                                                                                                插一个插曲。上次在湾区的一个大会上,一个小朋友问我:为什么你们 80、90 后程序员老是说不能写屎山代码?难道不行吗?我跟他说,因为叔叔是被踩坑踩过来的。

                                                                                                                小朋友回答了一句话,让我很震惊。他说:你怕屎山代码,是因为你要看代码、你要写代码,所以你怕屎山代码。但我是用 AI 写代码的,AI 不怕屎山代码,AI 也不担心屎山代码改不动,我也无所谓它是屎山代码。

                                                                                                                其实也是一样的道理——我们原来的逻辑里不能写屎山代码,是因为人写人改。这个执念的前提,本身是会变的。

                                                                                                                6.3 第一次 AI Coding,我们只走到了机械化

                                                                                                                当我们第一次出现 AI Coding 的时候,其实还没有到软件工厂,只走到了第二步,对标的还是工业的机械化生产状态——我们还是单个人用单个工具,只是效率更高的生产。只有到了真正用大量 Agent 去驱动一条流水线生产软件的时候,才相对来说算是个流水线。多个流水线自然就会变成一个大的自动化软件生产工厂。

                                                                                                                6.4 高 T 程序员就是当年的八级钳工

                                                                                                                在机械工业化的过程中,有没有一个角色很像今天程序员的焦虑和变化?其实是有的,就是钳工。我小时候经常听人说八级钳工,因为他要靠手工去确认自己搓出来的螺丝是不是足够精密,大量的手工活和手工艺术活都在他手里。当时最值钱的就是这些八级钳工,他能做出最精密的螺丝。

                                                                                                                对标今天,就是我们的高 P、高 T 程序员。因为他的技能足够好,对代码的感觉足够好,整个逻辑思维足够好,算法足够好,所以他能写出精妙的代码来。他就是当年的八级钳工。

                                                                                                                但你再看现在的工厂里,八级钳工到底还有没有用?我认为是有用的,因为这些八级钳工把他的经验变成了数控机床的精准代码,只是他不出现在第一线了。第二,生产过程也不再需要这么多八级钳工了,更需要的是设计数控机床这类生产线的那帮人。而你说设计这些精密数控机床的人,难道他不是八级钳工吗?他只是换了一个形态的八级钳工。

                                                                                                                所以最后的软件工厂会变成什么样?我觉得更多的是变成一条条可控的流水线,有多少条流水线在并行生产,取决于这个工厂是不是足够自动化。原来大部分的八级钳工,可能会蜕变为看着流水线过程的人——因为毕竟有大量需要人工确认的、有些没有澄清的地方,需要技术功底比较好的同学去确认掉。这部分就是现在手工里比较好的那帮程序员,他们未来要做的事,可能反而被放大了。

                                                                                                                事实上现在也看到了,当我们还没有有效组织的时候,原来技术比较好、能力比较好的这帮程序员,被 AI 放大的效果就更好。未来这帮人可能会被放得更大。

                                                                                                                6.5 码农变知识工程师,管理者变目标定义者

                                                                                                                那些原来我们称为码农、搬砖头的兄弟呢?他们可能不再需要去码那些胶水代码。我觉得更多的会变成知识工程师——把整个企业的知识,比如我刚才讲的体系里的本体,去确认掉、跟进掉,不停地完善业务的规则和流程,让大量的证据链去做复盘和监控。

                                                                                                                企业的管理者则会变成:把整个业务目标梳理清楚,然后经过这样一个软件工厂,最终交到使用者手里去验证是不是对的。我觉得当 AI 变成一个生产要素的时候,也就代表软件工程这件事会进到新的工业时代了。

                                                                                                                07

                                                                                                                结语

                                                                                                                今天讲的这些,我不敢说都是对的。我们走的这四条路里,前三条都是被我们自己撞出天花板的:老城改造把效率困在了单点,精益流程把知识做成了电子垃圾,全民造物把信息孤岛请回来了。第四条路目前也只是在一个小的业务场景里闭环跑通,它还是个实验品。

                                                                                                                但有几个判断我是相对确定的。第一,AI 编程真正改变的不是程序员个人的技能,而是软件生产的组织方式和生产关系,我们正在从手工业进入工业化。第二,效能提不上来的根本原因不在模型、不在 Agent,而在于我们仍然用「以人为中心」的方式去组织一件已经「以 AI 为中心」的工作——项目事实还留在人的脑子里,每个人的 AI 之间互不相通,token 大量被重复浪费。第三,能把这件事补上的,不是更强的工具,而是把目标、上下文、依赖和证据链真正管起来的组织能力,以及有人愿意去做企业知识工程这件苦活。

                                                                                                                对每个技术人来说,我还是那句以史为鉴的话:这是一个十字路口,谁先把被释放出来的生产力投到新的领域,谁就有机会。而程序员恰好是这场变化里最先拿到新武器的一批人——带着武器去大航海,到了新大陆,你就是降维打击。

                                                                                                                -End-

                                                                                                                原创作者|王晓波

                                                                                                                感谢你读到这里,不如关注一下?👇

                                                                                                                图片

                                                                                                                📢📢来抢开发者限席名额!点击下方图片直达👇

                                                                                                                扫码领取腾讯云开发者专属服务器代金券!

                                                                                                                图片

                                                                                                                跳转微信打开

                                                                                                                ❌