上个月给一个内部团队演示 Agent,我当场跑了五个任务,五个都过。有人问线上成功率多少,我说还没接真实入口。一周后入口接了,第一周的端到端成功率是 54%。

我没有太意外。真正让我在意的是另一件事:把那五个演示任务原样放进评测集重跑,成功率还是 100%。也就是说,我手上曾经同时存在一份 100% 的评测报告和一条 54% 的线上曲线,它们描述的是同一个系统,而且两份数据都是真的。

这篇讲的就是这两条曲线之间那段距离。怎么把「感觉还行」变成可比较的数字,怎么在出事之后知道当时发生了什么,以及怎么算清楚一个任务到底花了多少钱。这三件事看起来分散,实际是同一套东西的三个面:你只有先能看见,才能比较;能比较,才能归因;能归因,才知道该改哪里。

一、演示成功率和线上成功率是两个量

先把那 46 个百分点拆开。它主要来自三个地方,每一个都不是模型的锅。

样本偏差。 我挑的那五个任务,都是自己最近处理过的、结构清楚的问题。它们共享一个隐蔽的特征:我知道该给什么输入、该期待什么输出、哪里可以含糊。真实入口进来的任务里,有相当一部分需求本身是模糊的,比如「帮我把这个报表弄好看点」,这里的「好看」没有判定标准;还有一部分输入是脏的,缺列、编码错、字段名前后不一致、金额单位混着元和分。这些样本从来没进过我的演示集合。

演示效应。 演示的时候我坐在旁边。Agent 走偏,我会补一句「不是那个文件,是 config 下面那个」;它要删错东西,我会喊停。这句话线上不存在。所以我测的其实不是 Agent,是「Agent 加一个随时待命的我」。这个组合的成功率当然高,因为人承担了纠错、补充上下文、判断何时该停的工作,而这些恰恰是最难自动化的部分。

长任务的方差。 这一点最容易被低估。成功率在长任务里是乘出来的,不是加出来的。

单步准确率 10 步 20 步 40 步
98% 82% 67% 45%
95% 60% 36% 13%
90% 35% 12% 1.5%

而且真实的衰减比这张表更快,因为步与步不独立。第三步读错了文件,后面十七步都在错误的前提上跑;错误的观察还会留在上下文里,继续污染后面的判断。这就是 /AI/07/ 里说的「一错再错」:不是每一步都错,是错了一次之后,后面每一步都被带偏。

三条合起来,可以得到一个不太舒服的结论:演示成功率不是成功率的估计值,它只是「这套流程在最理想条件下能跑通」的存在性证明。 存在性证明有价值,它能告诉你这条路走得通;但它不能告诉你这条路有多宽。

还有一个更隐蔽的效应:同一个任务跑第二遍,你会更强。你知道了该先给它哪个文件、该提醒它哪条约束、哪一步会卡住。这种「学习」发生在你身上,不在系统里。所以反复跑同一个 demo 会持续给你虚假的信心,而线上每次都是第一次。

二、三层评测,问的是三个不同的问题

评测不是一个动作,是三个高度不同的动作。混在一起谈,就会出现「我们评测过了」这种没有信息量的话。

层级 回答的问题 主要指标 单次成本 频率 盲区
单步 这一次工具调用对不对 工具选择准确率、参数合法率、参数值正确率 秒级,几分钱 每次提交 单步全对,任务照样失败
任务级 端到端能不能做成 成功率、平均轮数、平均 token、P95 时长 分钟到小时级 发布前 环境不稳会造假失败
线上 真实分布下表现如何 A/B 差异、介入率、放弃率、单位成本 一周起步 持续 慢,且只有一次机会

单步评测测的是「该调 A 的时候有没有调 A、参数填得对不对、有没有多余调用」。它最大的好处是可以脱离真实环境:把工具返回 mock 掉,一天能跑几百条,成本低到可以塞进每次提交的流水线。它最大的盲区是局部正确不等于全局正确:三个工具都调对了,顺序错了,任务照样失败;该并行的时候串行,轮数翻倍,成本上去但成功率不动。

任务级评测是在固定环境里跑端到端。所谓固定,指的是仓库快照固定到某个 commit、数据库灌同一份种子数据、外部服务用同一份录制回放。指标里我最看重两个:按任务类型分桶的成功率,和 P95 时长。前者告诉你哪类任务在拖后腿,后者告诉你用户体验的尾部有多长。这一层的成本主要在环境:一条用例几分钟到几十分钟,五十条跑一上午;环境不稳会引入假失败,这是最大的坑,很多人第一次搭任务级评测,一半时间在修环境而不是看 Agent。

线上评测是唯一反映真实分布的一层。做法无非三种:小流量 A/B、人工抽检、看行为指标(介入率、放弃率、重试率)。它最贵也最慢,要等一周才有统计意义,而且用户不会给你重跑的机会。但它有一个别的层给不了的东西:真实的长尾。你在评测集里永远造不出用户那句「就那个,你懂的」。

三层不是替代关系,是漏斗。单步挂了,不配进任务级;任务级不过,不配上线上。反过来也成立:前两层都过了,线上照样可能翻车,因为分布不同。所以三层都得有,只是频率不同。

任务级的执行骨架不复杂,但有几个细节决定数据可不可信。

1
2
3
4
5
6
7
8
9
def run_suite(cases, model, repeats=3):
for case in cases:
for i in range(repeats):
env = setup(case.env) # commit + 种子数据,每次重建
trace = run_agent(case.input, model)
ok = check(case.expect, env, trace) # 优先走 assert
record(case.id, i, ok, trace.rounds, trace.tokens, trace.duration)
teardown(env)
return aggregate(group_by="task_type") # 分桶算成功率与 P95

repeats 不能是 1。同一个模型、同一个输入跑三次,结果经常不一致,这是 Agent 的常态而不是 bug。三次里过两次才算通过,比单次通过更接近真实。汇报时也别只报一个数,报「通过率」和「方差」:一个 80% 上下浮动 20 个点的版本,比一个稳定 75% 的版本难用得多。

setup 每次重建也很关键。很多人为了省时间复用环境,结果上一条用例的副作用带到下一条,失败原因查半天,最后发现是测试自己的脏数据。

代价要说清楚:搭这套东西的投入,大概是一次演示的几百倍。值不值,取决于这个 Agent 是玩具还是要在生产里跑一年。我的经验是,只要有人依赖它的输出做事,就必须有第二层;只要有外部用户,就必须有第三层。中间状态最危险——只有第一层,却以为自己在做第二层的事。

三、golden set:从真实失败里取样

我见过的评测集,八成是这么建的:坐下来想十个「应该会难」的任务,写进去。这类集合测的是建集人的想象力,不是系统的弱点。真正难的地方往往平淡无奇,比如「这个字段有时候是空字符串有时候是 null」,你想破头也想不出来,但它一周能让 Agent 挂三次。

靠谱的做法是反过来的:每发生一次线上失败、一次人工介入、一次用户投诉,就抽一条用例进集合。 一条事故一条用例,三个月能攒到五十条,而且每一条都对应一次真实发生过的损失。这样建出来的集合有个副作用:它不好看,里面全是你出过的丑。但它有用。

一条用例至少包含五样东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
- id: gw-0142
source: trace/2026-11-08/8f3c2a
task_type: refactor
input: |
把 src/billing 下的金额计算统一到 decimal.js,禁止再用浮点。
env:
repo: checkout@9d1f2c
setup: npm ci
expect:
- type: test_pass
cmd: npm test -- src/billing
- type: grep_absent
pattern: "parseFloat|Number\\("
path: src/billing
judge: deterministic
tags: [long_task, forty_rounds, regression]

source 这一栏别省。它是回到现场的唯一入口,出问题时能直接看当时完整的执行记录,比任何事后描述都准。env 也要写死,尤其是 commit 号:环境漂移是任务级评测最常见的假失败来源。

expect 的写法有优先级:确定性断言(测试通过、grep 不到某个模式、schema 校验通过、数据库状态符合预期)优于状态检查(diff 只动了允许的文件),状态检查优于 rubric judge,judge 优于人工。原则只有一条:能写成 assert 的,绝不交给 judge。 judge 有方差,assert 没有;judge 会疲劳,assert 不会。

起步数量是 30 到 50 条。 少于 30 条,一条用例的成败就是 3 个百分点,你分不清是改进还是噪声。到 50 条,5 个点的差异勉强算信号。要比较两个版本,最好 80 条以上,并且按任务类型分桶,每桶至少 10 条,否则某一桶的成功率就是一个用例在决定。

用例还要标难度,至少按轮数分档:短任务少于 10 轮,中任务 10 到 25 轮,长任务 25 轮以上,分别报成功率。混在一起报,短任务会把总数拉得很好看,而长任务才是真实工作的样子。我见过最典型的误判,就是拿一堆短任务的成功率去承诺长任务的交付。

维护有三件事要做。

  1. 每次修 bug 加一条,并且验证它在修复前失败、修复后通过。 只加不验,你加的可能是一条本来就过的用例,测不到这个 bug。
  2. 定期清理从不失败的用例。 它们要么太简单,要么已经被更强的模型顺手解决了。留着只会把成功率稀释得很好看,掩盖真正的难点。
  3. 留一份 holdout,不参与日常调优。 调 prompt 的时候看 dev 集,发布前才跑 holdout。

第三条是为了防过拟合,这件事值得单独说。评测集过拟合的表现很典型:集合上 92%,线上一点没动。原因是你反复看着这批用例改 prompt,改到最后 prompt 里全是对这批用例的特判,比如「如果输入包含『统一到 decimal』则优先检查浮点写法」。这已经不是泛化,是背诵。

防线的做法有两种。一种是 dev 和 holdout 分离,dev 随便调,holdout 一个季度只跑几次。另一种是按时间切分:用上个月的失败调优,用这个月的失败验收。后者更接近真实场景,也更难作弊,因为新失败长什么样你事先不知道。

四、指标:成功率是最容易被做坏的那个

一张看板至少要放这几个数,缺一个都会导致误判。

指标 定义 为什么必须看
端到端成功率 达成验收标准的任务占比,按类型分桶 唯一能对外承诺的数
平均轮数 每个任务的平均循环次数 轮数涨而成功率不涨,说明在瞎试
平均 token 输入 + 输出 + 思考 token 之和 成本的直接来源
P95 延迟 95 分位的端到端耗时 用户体验由尾部决定
人工介入率 用户中途接管、补充、纠正的占比 比成功率更早暴露「假装完成」
单位任务成本 总成本 ÷ 成功任务数 唯一能和业务价值对比的数
失败类型分布 超时、工具错、幻觉完成、理解错需求… 决定该修哪里

「只看成功率」为什么会误导,用一组数说明。版本 A 成功率 62%,平均 18 轮,每任务 30k token;版本 B 成功率 71%,平均 41 轮,每任务 95k token。单看成功率,B 赢 9 个点,值得上线。算单位成功成本:A 是 30k ÷ 0.62 ≈ 48k,B 是 95k ÷ 0.71 ≈ 134k,接近三倍。如果这个任务省下的人工只值两块钱,B 就是每单亏一块。

成功率可以被「堆」出来。多试几次、多读几个文件、把不确定的地方都查一遍、失败了重来两轮,这些都能把成功率推上去,代价是轮数和 token。这不叫变强,叫用成本换分数。所以成功率和成本必须一起看,最好直接看「每个成功任务的成本」——它把两个数合成了一个,很难糊弄。

还有一种更隐蔽的做法:把任务拆得更细,让每一步都更容易成功。成功率涨了,但用户要做的判断变多了,总工作量没减少。指标上一切正常,体验上退了一步。所以成功率的定义必须绑在「用户拿到的结果」上,不能绑在「Agent 自己报告的状态」上。这两者之间的差额,就是幻觉完成。

介入率是我最看重的一个指标,因为它比成功率灵敏。模型开始「假装完成」的时候,成功率还没掉,介入率先涨:它报告说改好了,用户打开一看没改,自己动手。这类失败在成功率里可能被算成成功(因为最终任务确实完成了),但体验已经很差。介入率涨了而成功率没动,通常意味着它在把工作推回给人。

P95 延迟比平均值重要得多。平均值会被大量简单任务拉平:一百个任务里九十五个三分钟、五个二十分钟,平均四分半,看起来还行;但那五个人会觉得这个产品不能用。Agent 的延迟分布天生是长尾的,因为轮数分布就是长尾的。

失败类型分布决定你下一步该干什么。超时多,调预算和超时;工具报错多,改工具和重试;幻觉完成多,加验证和断言;理解错需求多,加澄清环节;权限被拒多,改审批流程。只看总成功率,你不知道该动哪一块,通常的结果是去换一个更强的模型,然后发现数字没变。

五、LLM-as-judge:把它当成一个有偏见的实习生

开放式输出没有唯一答案。重构得好不好、报告写得清不清楚、回复的语气合不合适,这些写不出 assert,只能让模型来判。这件事可行,但前提是承认它有偏见。

三种偏见最稳定,几乎每个 judge 都有。

位置偏差。 成对比较时,裁判倾向于选第一个(也有模型倾向选第二个),偏移量能到十个百分点以上。这意味着你交换一下顺序,结论就可能翻转。

长度偏好。 更长、更多小标题、更多列表的答案得分更高,哪怕内容更空。这是最顽固的一种,因为训练数据里「详细」和「好」高度相关。你写 rubric 说「简洁优先」也压不住,模型嘴上同意,打分照样偏向长的那份。

自评偏好。 同家族模型给自己家的输出打分偏高。用 A 评 A 的输出,胜率会虚高十几个点,而且它自己不知道。

缓解手段有六条,按性价比排序。

  • 用成对比较代替绝对打分。1 到 10 分在不同批次、不同 prompt 之间不可比,「A 和 B 哪个更好」稳定得多。
  • 交换顺序各判一次,两次结论不一致记为平局。这一条能消掉大部分位置偏差,成本翻倍但值得。
  • 裁判换一个不同家族的模型。别让被评的模型自己当裁判。
  • rubric 写可观察的条目。「是否列出了三个风险点」可判,「分析是否深入」不可判。
  • 人工抽检 30 到 50 条,算 judge 和人的一致率。低于 70% 的 judge 只能当参考,不能当门禁。
  • 抽样评,不要全量评。judge 的 token 成本不低,而且它评得越多,你对它的盲区越自信。

一段能用的 judge prompt 骨架,重点在最后两行。

1
2
3
4
5
6
7
8
9
10
你在比较同一个任务的两份输出,判断哪一份更符合下列标准。
只依据给定的输出,不要补充外部知识,不要因为篇幅长而加分。

标准(按重要性排序):
1. 是否覆盖了任务要求的全部三个改动点
2. 是否保留了原有的公开接口签名
3. 是否给出了可执行的验证步骤

输出 JSON:{"winner": "A" | "B" | "tie", "reason": "<50 字以内"}
拿不准时输出 tie,不要强行选一个。

最后那句「拿不准时输出 tie」很关键。不写它,裁判几乎不输出平局,会把噪声当信号,于是你在一堆没有差异的版本之间认真比较,得出一些似是而非的结论。

还有一条经验:judge 适合做相对比较,不适合做绝对门禁。 「B 比 A 好」它判得还算准;「这个任务算不算成功」它判得不准,因为成功涉及环境状态、外部依赖、用户真实意图,这些它看不到。门禁还是要靠 assert 和人工。

六、可观测性:出事时你要能回答「当时发生了什么」

没有 trace 的 Agent,出事之后只能靠复现。而 Agent 的复现率很低:模型版本可能悄悄变了,温度不完全确定,工具返回的外部数据也变了,上下文压缩的时机还依赖当时的窗口占用。所以现场必须当场记下来。

一次 trace 至少记四类东西:这一轮模型看到了什么(摘要)、它决定做什么(工具名与参数摘要)、花了多久多少钱(耗时、token)、结果是什么状态(成功、失败、被守卫拦下)。下面是一条单轮记录的样子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
{
"trace_id": "8f3c2a",
"task_type": "refactor",
"session_id": "s-4471",
"model": "claude-sonnet-4-5@2026-09",
"round": 17,
"ts": "2026-11-08T14:22:31Z",
"input": {
"tokens": 48210,
"cached_tokens": 41000,
"digest": "read src/billing/tax.ts L1-120; user asked to unify decimal"
},
"action": {
"tool": "edit_file",
"args_digest": "path=src/billing/tax.ts, old=38-52, new=38-49"
},
"result": {
"status": "ok",
"duration_ms": 1840,
"output_tokens": 612,
"thinking_tokens": 0
},
"context": {
"compressed": true,
"compress_ratio": 0.41,
"guard_triggered": null,
"retry": 0
}
}

几个字段值得解释。

digest 不是原文,是摘要。原文太大,可能含隐私,但摘要必须足以回答「它当时基于什么做的决定」。我一般记「读了哪个文件的哪几行」加一句意图,这两样加起来通常能还原判断依据,而体积只有原文的百分之一。

compressed 和 guard_triggered 单独记,是因为它们是行为突变最常见的原因。很多「模型突然变笨」的 case,回看 trace 会发现上一轮刚压缩过,或者某个守卫拦了一次写入,它于是换了个方案。不记这两个字段,你会花两天去怀疑模型,最后发现是自己写的压缩 prompt 把约束吃掉了。

retry 也要记。重试次数突然上升,通常意味着某个工具开始不稳定,而不是模型变差。

trace 的存储按用途分级就够:最近七天全量可查,三十天内保留结构化字段和失败原文,更早的只留聚合指标。查询入口做两个——输入 trace_id 看完整链路,输入用户 ID 看他最近十次任务。这两个查询覆盖八成排查场景,先别急着做分析平台,分析平台通常没人用。

任务级还要记:总轮数、总成本、最终状态、是否人工介入、介入发生在第几轮。最后这个字段很有用,它能告诉你「人一般在哪里放弃」,那通常就是系统最薄弱的环节。

采样策略上,我的做法是结构化字段全量记,输入原文按比例采样,失败任务百分之百保留原文。别一上来就全量存原文,成本和合规都扛不住;也别只存结构化字段,出事时没有原文,摘要里的那点信息不够用。

七、成本归因:最贵的那一类调用通常不是模型

第一次认真拆账的时候,我以为大头是输出 token,因为单价贵。拆完发现不是。

操作 典型 token 说明
读一个 400 行 TS 文件 4k~6k 一次读十个就是 50k
读一份 2000 行日志 25k~35k 里面有用的可能只有三行
一次 1080p 截图 1k~2k 截五次等于又读半个代码库
一次失败测试的堆栈 0.5k~2k 全量回灌很常见
一次正常模型回复 0.3k~1k 输出单价高,但量小

结论很反直觉:在 Agent 里,钱主要花在「看」上,不是「想」上。一个任务输出几千 token,输入可能几十万。这也解释了为什么降 temperature、缩短回答这类优化,对账单几乎没有影响,而「别整文件读取」能立竿见影。

拆账要按三个维度做,缺一个都会漏。

按任务类型拆。 哪类任务在亏钱。常见的情况是:简单任务(分类、抽取)单位成本极低,复杂任务(重构、调试)单位成本是它的几十倍,但两者定价一样。这个发现会直接改变你的产品策略——要么复杂任务提价,要么限制它的使用范围。

按工具拆。 哪几个工具吃掉大部分 token。通常符合二八分布:两三个「观察类」工具占了六七成。知道是哪几个,优化才有靶子。

按轮次拆。 成本是随轮次线性增长,还是越往后越陡。如果是后者,通常有两个原因:上下文压缩没做好,每轮都在带一份越来越胖的历史;或者工具返回越来越长,比如反复读同一个大文件的不同片段。按轮次画一条曲线,这两种情况一眼能看出来。

失败任务的成本要单独算。 一个死循环跑二十轮,每轮都带全量上下文,成本可以是成功路径的几十倍。很多团队的平均成本看着正常,是因为大量简单任务拉平了曲线;把失败任务单独拎出来,会发现它们吃掉了三四成预算,而且没产出任何价值。这是最容易优化的一块,因为砍它不影响成功率。

优化顺序很重要,反了会亏。

  1. 先砍失败任务的成本:重试上限、循环检测、超时预算。这一步通常能省三成,且不影响成功率。
  2. 再砍成功路径的观察成本:精确检索代替整文件读、结果摘要回灌、截图只在必要时用。
  3. 最后才考虑换便宜模型或降思考档位。

顺序反了会怎样:先换便宜模型,成功率掉,重试变多,总成本反而上升,然后你以为是模型不行,又换回去。这个循环我见过不止一次。

还有一个常被忽略的成本项:压缩本身。压缩要调用一次模型,长任务里压十几次,这笔开销能占到总成本的一成左右。压缩频率和压缩质量要一起看,压得太勤反而更贵,也更容易丢信息,这一点在 /AI/02/ 里算过。

八、回归与告警:变更必须付门票

三类变更都要跑回归,缺一类就会漏。模型版本(包括厂商的静默小版本更新)、prompt 改动、工具变更(新增、改描述、改返回结构)。第三类最容易被忽略,但改一句工具描述就能让调用准确率掉十个点,因为它改变了模型对这个工具边界的理解。

回归分三级,成本递增。

  • 快速集:10 到 15 条,覆盖主要任务类型和已知失败模式,两分钟内跑完,每次提交跑。它拦不住所有问题,但能拦住「一改就崩」。
  • 全量集:50 到 80 条,半小时,发布前跑。这一级要看分桶成功率,不只看总数。
  • 灰度:百分之一到五的流量,看一天。前两级都是在你的环境里跑,只有这一级能碰到真实分布。

告警的阈值建议这么设。

信号 阈值 说明
端到端成功率 7 日移动平均跌破基线 10 个点 单日波动不算
人工介入率 相对基线翻倍 比成功率更早报警
P95 时长 超过 SLA 的 1.5 倍 尾部先坏
单位任务成本 超预算 30% 防止悄悄变贵
工具错误率 单工具连续上升 通常是外部依赖挂了

告警纪律有两条。不要对单点告警,Agent 方差大,单日波动五个点是正常的,天天响的告警等于没有告警,用移动平均加连续窗口。告警必须带 trace_id 和样本,否则收到告警的人第一件事是去翻日志,五分钟的响应变成五十分钟。

回归结果本身也要存。同一批用例连续几个版本的成功率曲线,比单次结果有用得多:它能告诉你是在慢慢变好,还是在某次改动后掉了一个台阶。掉台阶的情况用二分定位版本很快;缓慢下滑通常意味着评测集已经跟不上系统,或者外部依赖在悄悄退化。

还有一条容易被跳过:告警要能区分「模型变差」和「外部变了」。工具错误率上升、超时变多,大概率是外部依赖的问题;成功率下降但工具都正常,才轮到怀疑模型或 prompt。这个判断顺序能省很多时间。

常见的坑

  • 用自己想的题建评测集。 测的是想象力,不是系统的弱点。
  • 演示时人在旁边纠错,把结果当成功率。 测的是人机组合,不是 Agent。
  • 只看成功率,不看轮数和成本。 分数可能是拿钱堆出来的。
  • 拿 LLM judge 当门禁,不做人工校准。 一致率没算过就敢用,等于把方差引进发布流程。
  • 只记成功日志,失败现场什么都没留。 出事之后只能靠复现,而复现率很低。
  • 记了原文但没记摘要。 几万行日志里找不到「当时为什么这么决定」。
  • 全量存 prompt 原文。 成本和合规双爆,最后被迫删库。
  • 用单日数据判断版本好坏。 结论一半是噪声。
  • 改了工具描述不跑回归。 最隐蔽的一类回归。
  • 评测集调到 95%,就以为线上也是 95%。 过拟合的典型症状。

检查清单

  • 有一份从真实失败里抽出来的 golden set,至少 30 条,每条带来源 trace。
  • 每条用例写清了输入、环境(含 commit)、期望、判定方式。
  • 判定优先用 assert,judge 只用在确实写不出断言的地方。
  • 单步、任务级、线上三层都有,频率不同,职责不混。
  • 成功率和单位成功成本放在一起看。
  • 介入率、P95、失败类型分布都在看板上,且有人定期看。
  • judge 做过人工一致率校准,低于 70% 不当门禁。
  • trace 记了输入摘要、工具与参数摘要、耗时、token、状态、是否压缩、是否触发守卫、重试次数。
  • 失败任务保留完整现场,成功任务按比例采样。
  • 成本按任务类型、工具、轮次三个维度拆过账,失败任务单独算。
  • 模型、prompt、工具变更都跑回归,线上告警用移动平均。

评测这件事的收益很不对称。不做的时候,你会觉得系统挺好,因为你能看到的只有自己想看的那些 case;做了之后,你会发现一堆从没想过的问题,而且这些问题大多不在模型上,在环境、在工具边界、在你对任务的理解。

我现在的习惯是:每次线上失败,先不急着改代码,先把它变成一条用例。改完之后跑一遍,确认这条从红变绿,再确认其他用例没变红。这个动作很慢,但它是唯一能让「这次修好了」变成「以后不会再犯」的机制。

成本也是同理。你不拆账,就永远不知道自己是在为智能付费,还是在为「读了三十个无关文件」付费。后者通常是大头,而且砍掉它不影响任何体验。

系列大纲与全部篇目见:Agent 原理与开发。

延伸阅读