近期备受关注的 SlopCodeBench(Orlanski et al., arXiv:2603.24755)揭示了一个令开发者深有共鸣的现象:Coding Agent 在多轮迭代开发中会不断往旧代码里打补丁,导致代码结构持续腐烂(Code Erosion)。更悲观的是,论文认为显式的质量提示词只能改善初始质量,无法改变退化速率,而且更贵。
我们在 GLM-5.3-flash 与 Claude Opus 5.5 上复现并扩展了这一基准,通过分步 vs. One-Shot 对照、快照嫁接(Splicing)、独立重构分离(Refactor-Only)、定期外生重构(Periodic Refactor)与全程内生约束(Anti-Slop)五组层层递进的实验,得出了截然不同的核心洞察:
- 指标假象(Metric Illusion):原论文的核心比例指标
erosion存在严重的“分母稀释悖论”与“阈值截断效应”,单看该指标既会漏报真实的巨型函数膨胀,也会误判提示词干预的斜率。 - 分步迭代的代价是“代码膨胀与入口淤积”:在严格对齐全量回归测试集后,分步迭代相比一次性给全量需求的 One-Shot 会多写 20%–30% 的代码(p = 0.03)、耗时与费用翻倍,且复杂度高度淤积在入口函数
main()中。 - 不是“不能”,而是“不愿”:在默认迭代中,Opus 5.5 在 25 次关卡转换中 0 次主动重构;但当我们单独下达“只重构”指令时,模型 6/6 次全部一次成功、测试零破坏,将单函数最高复杂度从 24–34 直接压回 8–13。所谓退化,本质是在“跨轮次失忆 + 隐藏历史测试”沙盒下的最小侵入式防御策略(Minimal-Invasive Patching)。
- 内生纪律完胜事后手术(且省钱 39%):在 Opus 5.5 上,全程施加
anti_slop约束不仅压低了初始复杂度,更将 8 关迭代的最高函数复杂度增量死死按在 0~+6(默认模式为 +14~+54),彻底压平了退化斜率!更反直觉的是,在长链路难题circuit_eval上,写好代码的anti_slop比一路堆“屎山”的默认模式总成本反而降低了 39%($13.12 vs. $21.40)。
缘起:Coding Agent 真的患上了“不可逆的架构退化症”吗?
用过 Claude Code、Cursor 或 OpenCode 的开发者几乎都经历过这种绝望:让 Agent 从零写一个新项目(Checkpoint 1),它写得干净利落;但当你连续给它提第 4、第 5、第 8 个增量需求时,它几乎从不重构旧架构,而是不断往入口函数里塞 if-elif 分支、复制粘贴相似逻辑,直到代码膨胀成一座连它自己都改不动的“意大利面条屎山”(Slop)。
为了量化这一现象,Orlanski 等人推出了 SlopCodeBench——一个包含 36 道多阶段演进编程题的评测基准。每道题分为多个连续的 Checkpoint(关卡):每一关在全新的容器中启动,只保留上一关的工作区代码,不保留上一关的对话记忆,也不向 Agent 暴露历史回归测试集。
原论文通过大规模评测给出了三个相当悲观的论断:
- 迭代必然腐烂:77%–80% 的轨迹会出现结构侵蚀(Structural Erosion)和冗余膨胀(Verbosity),例如 Opus 4.7 在
forge题目上的main()函数复杂度在 8 关内暴涨 7 倍(NeurIPS 2026)。 - 早期结构锁死命运:没有预设架构时,早期写坏的结构会被后续迭代不断放大。
- 提示词救不了退化斜率(最关键的结论):作者测试了要求模块化和限制函数大小的
anti_slop提示词,声称它“只能把初始 erosion 降低最多 62.3%,但无法改变每关 +1.3 个百分点的退化速率(Prompts move the intercept, not the slope),同时还会让单关成本增加 12.1%”(参见 Medium 上的讨论)。
读完原论文,我们产生了一个强烈的疑问:当代顶尖模型真的连几百行代码的模块化设计都维持不住吗?为什么加上 anti_slop 提示词后,论文看到的退化速率依然没有改变?
为了搞清楚背后的真实机制,我们在 SprocketLab/slop-code-bench(v1.0)上搭建了完整评测环境,使用 Claude Code(v2.1.44)作为统一 Harness,在 GLM-5.3-flash 与 Claude Opus 5.5 上展开了一场顺藤摸瓜的因果排查。
第一步:先校准尺子——什么是“函数复杂度”?为什么原论文的 erosion 指标会失真?
在看数据之前,我们先用一句话对齐衡量代码质量的标尺——函数复杂度(即软件工程中的圈复杂度,Cyclomatic Complexity,简称 CC):
💡 30 秒读懂“函数复杂度”:你可以直接把它理解为一个函数内部有多少条独立的逻辑分支路径(每多一个
if、elif、for、while、and/or或case,复杂度就 +1)。
- 复杂度 1~10:结构清爽、职责单一的健壮函数(业界提倡的标准上限);
- 复杂度 11~20:分支较多、开始变得难以维护的复杂函数;
- 复杂度 > 20:高危的“臃肿大函数”,充斥着多层嵌套与耦合;
- 复杂度 > 50:灾难级的“上帝函数(God Function)”,几十个分支揉成一团,改一行极易崩全局。
在下文中,我们重点追踪整个代码库中最臃肿的那个瓶颈函数,称之为最高函数复杂度。
在复现默认 just-solve 模式时,我们首先验证了原论文点名的经典案例。在 forge 题目(8 关)上,Opus 5.5 的表现确实印证了“入口函数膨胀”——到了第 8 关,全场最复杂的函数就是入口 main(),单个函数里塞进了近 50 个分支:
| 关卡 | 测试通过 | 代码行数 | 最高 CC | main() 行数 / CC |
|---|---|---|---|---|
| 第 1 关 | 38 / 40 | 238 | 21 | 36 行 / 15 |
| 第 4 关 | 136 / 142 | 562 | 33 | 47 行 / 19 |
| 第 8 关 | 271 / 295 | 1138 | 49 | 117 行 / 49 |
CC 为圈复杂度,最高 CC 指全场单函数最高复杂度;最后一列依次为 main() 行数 / CC。
然而,当我们观察原论文定义的核心指标 erosion(结构侵蚀度)时,却撞上了一个诡异的反常现象:
- 在
forge上,最高函数复杂度从第 1 关的 21 一路飙升到第 8 关的 35~49,但论文指标erosion却从 0.78 降到了 0.69! - 在
code_search上,Opus 5.5 分步迭代的erosion甚至从 0.82 大幅降到了 0.49!
难道模型在边写边重构,代码越写越健康?我们最初差点信了这个数字。但当我们拉出语法树(AST)逐个检查函数变化时,发现没有任何一个函数被删除或拆分,最高函数复杂度实际上从 18 涨到了 32!
为什么最核心的函数越来越臃肿,erosion 反而下降了?根源在于原论文对 erosion 的数学定义——它算的是“复杂度超过 10 的函数占所有函数总复杂度质量的比例”(Hugging Face):
作为一个带截断阈值的比例指标,它存在两个严重的测量盲区:
- 分母稀释悖论:在
code_search第 3 关,Agent 一次性新增了 24 个极其简单的辅助小函数(复杂度仅 1~3)。这些小函数全部计入分母,瞬间稀释了高复杂度大函数的占比,制造出“结构侵蚀大幅好转”的假象。同理,如果算全项目的“平均函数复杂度”,也会被这批小函数拉低。 - 阈值截断效应(Threshold Cliff):因为分子只统计复杂度 > 10 的函数,如果一个干预手段(比如
anti_slop)在第 1 关把所有函数复杂度都压在 ≤ 10,此时erosion是完美的 0.00;到了后期关卡,哪怕只有一两个核心解析函数从复杂度 10 轻微涨到 11,erosion就会从 0.00 突然跳升。
因此,我们在所有后续实验中,将绝对指标——最高函数复杂度(Max CC)与高复杂度函数个数(复杂度 ≥ 10 / 复杂度 ≥ 20)作为主指标,同时汇报论文的 erosion 和 verbosity 作为对照。
第二步:分步迭代 vs. One-Shot——高复杂度是任务固有的,还是“迭代”出来的?
在深入剖析退化机制前,必须先回答一个基础问题:末关代码复杂度高,究竟是因为整道题的最终需求本身就这么复杂,还是因为“分步盲盒迭代”模式导致的?如果把所有关卡的题面拼成一份,一次性交给模型(One-Shot),结果会怎样?
1. 修正评测盲区:补齐 One-Shot 的回归测试集
在实验设计中我们发现,原仓库的 One-Shot 模式由于只生成最后一关,默认只跑最后一关的测试,不包含前几关的回归测试(Regression Tests)。为了保证绝对公平,我们使用 eval-snapshot 将所有 One-Shot 快照在完整测试集(含全部历史回归测试)上重新进行了评测。
2. GLM-5.3-flash 上的 14 对配对实验(6 道题)
在完全一致的配置下(Claude Code 2.1.44,thinking=none,just-solve),我们在 GLM-5.3-flash 上完成了 6 道题共 14 对“分步 vs. One-Shot”对比:
| 指标 | 分步迭代 | One-Shot | 配对差 | One-Shot 更优 |
|---|---|---|---|---|
| 完整测试集通过率 | 81.9% | 85.4% | +3.6pp ± 1.1 | 10 / 14 |
| 代码行数 (SLOC) | 1756 | 1378 | −379 ± 171 | 11 / 14 |
| 最高函数复杂度 | 53.2 | 42.4 | −10.8 ± 5.4 | 11 / 14 |
erosion(论文比例指标) | 0.720 | 0.721 | +0.001 ± 0.034 | 7 / 14 |
| 单题费用(元) | ¥3.86 | ¥1.84 | −2.03 ± 0.48 | 13 / 13 |
| 单题耗时(分钟) | 173 min | 78 min | −95 ± 22 | 14 / 14 |
配对差 = One-Shot − 分步迭代,报告均值 ± 标准误(SE)。通过率差以百分点(pp)计;费用为人民币元,耗时为分钟。
(注:若改为比较“3 轮运行中最好的一次”,两者通过率差距基本消失,差值仅 +0.1pp,说明正确性差异本身并不稳健。)
为了排除“未完成关卡”对代码量的干扰,我们进一步筛选出两边需求完成度都达到 100% 的 13 对样本进行置换检验(Permutation Test):
| 指标 | 均值差 | 分步更大 | p 值 |
|---|---|---|---|
| 代码行数 (SLOC) | +414 行 | 11 / 13 | 0.03(显著膨胀) |
erosion | −0.001 | 7 / 13 | 0.98 |
verbosity | +0.044 | 9 / 13 | 0.52 |
两种模式均完成 100% 需求,共 13 对样本。均值差 = 分步 − One-Shot;p 值来自置换检验。
3. Claude Opus 5.5 上的对照与“复杂度淤积位置”差异
我们在 Opus 5.5 上同样进行了 forge(3 对)和 code_search(1 对)的分步 vs. One-Shot 对比:
| 题目 | 配对数 | 通过率 | 函数数 ≥ 10 | 代码行数 |
|---|---|---|---|---|
forge | 3 对 | 91.1% / 90.2% | 11.0 / 11.3 | 1246 / 1090 |
code_search | 1 对 | 91.3% / 93.3% | 8 / 10 | 2223 / 1680 |
成对数值依次为分步 / One-Shot;函数数统计 CC ≥ 10,代码行数为 SLOC。
结合两个模型的数据,我们得到了关于“分步迭代 vs. 全局一次性生成”的清晰图景:
- 分步迭代必然带来显著的代码膨胀(Code Bloat)与双倍成本:在实现完全相同需求的前提下,分步迭代比 One-Shot 多写 15%–30% 的代码(GLM 上平均多写 414 行,p = 0.03),且耗时与费用翻倍。
- 全局视野改变了“复杂度的淤积位置”:虽然两边高复杂度函数的总数相近,但在 Opus 5.5 的
forge实验中,分步模式 3 次中有 2 次全场最复杂的函数就是入口main()(不断往入口追加分支);而在 One-Shot 模式下,main()函数全部非常精简,复杂度被合理地分配到了各个具体的子命令处理函数中。
第三步:快照嫁接(Splicing)——坐实“破窗效应”的路径依赖
既然分步迭代会把逻辑淤积在入口函数并导致代码膨胀,那么在多轮迭代中,究竟是“后几关需求变难了”,还是“前几关写坏的底子锁死了后续迭代”?
为了分离这两个因素,我们在 forge 上设计了一个反事实快照嫁接实验(Splicing):
- A 组(自己的起点):让 Opus 5.5 正常从第 1 关跑到第 8 关。
- B 组(参考答案起点):在第 3 关结束时,悄悄把工作区代码替换成模块化良好的参考答案(抹除 canary 标记,测试 101/101 通过),然后让同一个模型用完全相同的默认
just-solve提示词继续跑第 4–8 关。由于每关都是全新会话,Agent 根本不知道这代码是不是自己写的。
| 指标 | 自身起点(A) | 参考起点(B) | 第 8 关参考答案 |
|---|---|---|---|
| 最高函数复杂度 | 41.0 (35, 39, 49) | 25.7 (25, 26, 26) | 26 |
| 高复杂度大函数个数(复杂度 ≥ 20) | 4.3 | 1.3 | 3 |
main() 函数复杂度 | 34.0 | 19.0 | — |
| 第 3→8 关最高函数复杂度增量 | +11.3 | +5.7 | — |
| 最终测试通过率 | 91.1% | 98.2% | 100% |
第 8 关指标报告均值,括号内为三次运行的数值;增量覆盖第 3→8 关,大函数指 CC ≥ 20。A 组从自身第 3 关快照继续,B 组在第 3 关替换为参考答案。
结果非常清晰:换上干净的模块化底子后,哪怕只用最朴素的 just-solve 提示词,Opus 5.5 在后 5 关的最高函数复杂度增量也立刻减半(+5.7 vs. +11.3),最终的最高函数复杂度(25.7)几乎与人类参考答案(26)完全持平!
这从因果上证实了 Coding Agent 极强的上下文顺从性(Context-Following / 破窗效应):给它一个清爽的多模块架子,它就会顺着分模块写;给它一个塞满分支的巨型 main(),它就会毫不犹豫地继续往里堆 elif。
(注:严谨起见,参考答案起点同时具备“结构更好”和“存量 Bug 更少(101/101 vs. 92%–94%)”两个优势,两者在此实验中未完全分离。)
第四步:拆解“为什么不重构”——是能力缺陷(Can’t),还是激励缺失(Won’t)?
既然好底子这么重要,为什么 Agent 在默认迭代中不去顺手整理代码,把坏底子重构成好底子呢?
1. 默认状态下的“绝对懒惰”
我们编写脚本扫描了所有分步轨迹中关卡之间的语法树演化,统计“函数被拆分、删除或复杂度显著下降”的主动重构事件:
| 实验组 | 关间转换 | 重构事件 |
|---|---|---|
Opus 5.5 forge(自己的起点) | 21 | 0 |
Opus 5.5 code_search | 4 | 0 |
Opus 5.5 forge(参考答案起点) | 15 | 2 |
| GLM-5.3-flash 全部分步轨迹 | 54 | 10 |
排查那极少数几次“函数提取”事件后发现,它们全部是由新需求直接触发的被动复用(例如新命令需要复用过滤逻辑时才抽出一个公共函数,Agent 在日志里原话写道:“I’m sharing the unit list’s filter parsing and matching with the new commands rather than duplicating it”)。在全部 94 次关间转换中,没有任何一次是为了降低已有代码复杂度而主动发起重构的。
2. 独立下发 refactor_only 指令:惊人的 100% 零破坏重构能力
是因为模型不会重构吗?我们在第 4 关结束的快照上,插入了一次单独的会话,不给任何新功能需求,只下发一段简短的 refactor_only.txt 提示词(要求拆分高复杂度函数、改善模块化,并保持现有行为不变):
Claude Opus 5.5 · 第 4 关快照 · 六次 refactor_only 会话
空心圆为重构前,实心圆为重构后,数值越低越好。六次会话均保持了原有测试结果,包括重构前已失败的测试。悬停或聚焦任一行查看详情。
查看重构前后原始数据
| 题目 | 次数 | 测试:重构前→后 | 最高 CC:重构前→后 |
|---|---|---|---|
forge | 3 次 | 完全不变(136/142, 132/142, 136/142) | 32 → 8、29 → 11、28 → 8 |
circuit_eval | 3 次 | 完全不变(三次均为 430/430 → 430/430) | 29 → 9、34 → 13、24 → 9 |
每题均在第 4 关快照上独立重构三次;依次报告重构前→后的测试通过数与最高 CC,所有运行的测试通过数均保持不变。
6 次独立重构全部一次成功,测试零损坏,最高函数复杂度直接腰斩再腰斩(从 24–34 的臃肿状态瞬间压回到 8–13 的清爽区间)!
这一结果彻底推翻了“Coding Agent 缺乏软件工程重构能力”的印象。退化的根源不是“做不到(Can’t)”,而是默认激励下的“不主动做(Won’t)”。
站在 Agent 的视角想一想:在 SlopCodeBench 的设置里,每一关的 Agent 都是一个刚刚空降接盘的“失忆开发者”——没有上一关的上下文记忆,更看不见前几关的回归测试集。在没有回归测试兜底的黑盒环境下,去大改一个陌生的旧代码库,改出 Regression Bug 的风险极高;而“不动旧逻辑、只在入口或末尾追加分支”则是阻力最小、最安全的纳什均衡策略。
第五步:寻找最优解药——为什么“全程内生约束”完胜“事后定期手术”?
既然模型拥有顶级的重构能力,只是默认不触发,那么在工程实践中,我们应该“让它先快糙猛地写,每隔几关单独跑一次重构(事后外生手术)”,还是“从第一关起就在提示词里加上严格的代码质量约束(全程内生纪律)”?
我们在 8 关长链路难题 circuit_eval(以及 forge)上,对四种策略进行了正面交锋:
- A 组(不重构
just-solve):全程默认提示词。 - D 组(中途重构一次):第 4 关后运行一次
refactor_only,第 5–8 关继续用just-solve。 - P 组(定期重构):在第 2、4、6 关后各运行一次
refactor_only。 - C 组(全程
anti_slop):全程使用原论文自带的anti_slop提示词(要求“No god functions”、按职责分模块等)。
发现 1:中途重构只能救急,定期外生重构甚至会引发“跨轮次翻车”
先看第 4 关重构一次(D 组)能否在后续 4 关保住胜利果实:
| 题目 | 组别 | C4 最高 CC | C8 最高 CC | 增量 | C8 大函数数 |
|---|---|---|---|---|---|
forge | A 组:不重构 | 29.7 | 41.0 | +11.3 | 4.3 |
forge | D 组:第 4 关重构一次 | 9.0 | 14.3 | +5.3 | 0.0 |
circuit_eval | A 组:不重构 | 29.0 | 61.3 | +32.3 | 8.0 |
circuit_eval | D 组:第 4 关重构一次 | 10.3 | 34.3 | +24.0 | 5.0 |
增量 = C8 − C4 最高 CC;大函数指 CC ≥ 20。A 组不重构,D 组在第 4 关后重构一次。
在相对简单的 forge 上,一次重构带来的好结构基本保住了(末关最高函数复杂度仅 14.3,且零大函数);但在后续需求极其复杂的 circuit_eval 上,因为第 4 关重构只在单文件内拆了函数,到了第 8 关最高函数复杂度又重新累积到了 34.3。
那么,每隔两关就强制重构一次(P 组:第 2、4、6 关后各重构一次)呢?
circuit_eval | C1 | C2* | C3 | C4* | C5 | C6* | C7 | C8 |
|---|---|---|---|---|---|---|---|---|
| 最高函数复杂度 | 29 | 9* | 14 | 11* | 11 | 11* | 12 | 42 |
各关报告最高 CC;* 表示第 2、4、6 关重构后的数值,C8 为末关。定期重构条件仅运行一次。
结果暴露了“定期外生重构”的三大硬伤:
- 末关剧烈反弹:在没有重构的最后一关,最高函数复杂度一关之内直接从 12 跳到了 42。
- 费用翻倍:总开销高达 $43.58,是不重构组($21.40)的整整 2 倍。
- 引发跨轮次回归错误(正确率从 99.8% 跌至 90.5%):第 8 关测试仅通过 512/566。排查轨迹发现,三次重构本身都没有改坏任何一行代码(重构前后测试通过数 100% 一致);真正翻车的是第 3 关——当第 2 关后的
refactor_only会话把代码拆解成多文件结构后,第 3 关新空降的just-solveAgent 面对陌生的跨文件调用链,在添加新功能时改坏了第 2 关的旧逻辑,且此后一直未能修复!“外生手术强加的抽象结构”与“下一关默认短视模式”之间发生了严重的认知断层。
发现 2:全程 anti_slop 彻底锁死退化斜率,直接反驳原论文结论!
最令人振奋的结果出现在 C 组(全程 anti_slop)。看看 circuit_eval 8 关下来每关最高函数复杂度的演化轨迹:
Claude Opus 5.5 · circuit_eval · 8 关 · 最高函数复杂度(CC)
实线为 3 次运行的均值,阴影为最小–最大范围,并非置信区间。虚线为单次定期重构;方形标记 C2、C4、C6 的重构后数值。 悬停或用左右方向键查看各关数据;定期重构原始轨迹见前表。
查看 C1–C8 原始轨迹数据
| 运行 | C1 | C2 | C3 | C4 | C5 | C6 | C7 | C8 | 增量 |
|---|---|---|---|---|---|---|---|---|---|
just-solve (Run 1) | 16 | 25 | 27 | 29 | 33 | 42 | 53 | 62 | +46 |
just-solve (Run 2) | 21 | 28 | 30 | 34 | 41 | 51 | 72 | 75 | +54 |
just-solve (Run 3) | 10 | 18 | 20 | 24 | 30 | 50 | 40 | 47 | +37 |
anti_slop (Run 1) | 6 | 9 | 11 | 11 | 11 | 11 | 11 | 12 | +6 |
anti_slop (Run 2) | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 0 |
anti_slop (Run 3) | 10 | 10 | 10 | 10 | 10 | 10 | 10 | 11 | +1 |
各格为该关最高 CC,增量 = C8 − C1;circuit_eval 上每种提示词独立运行三次。
在 forge 和 circuit_eval 两道题共 12 次完整运行(各 3 对)中,两组结果没有哪怕一次重叠:
| 题目 | 提示词 | 次数 | C8 最高 CC | 增量 | C8 大函数数 | 通过率 | 费用($) |
|---|---|---|---|---|---|---|---|
forge | just-solve | 3 | 35, 39, 49 | +14 ~ +28 | 4.3 | 91.1% | $1.80 |
forge | anti_slop | 3 | 9, 10, 11 | 0 ~ +4 | 0.0 | 92.1% | $4.14 |
circuit_eval | just-solve | 3 | 47, 62, 75 | +37 ~ +54 | 8.0 | 99.8% | $21.40 |
circuit_eval | anti_slop | 3 | 10, 11, 12 | 0 ~ +6 | 0.0 | 99.6% | $13.12 |
C8 最高 CC 列出三次运行的末关值;增量 = C8 − C1。大函数数(CC ≥ 20)、通过率及完整运行的美元费用均为组内均值。
哪怕换回原论文自己的指标(erosion 与 verbosity),并对比原论文表 3 中 GPT 5.3–5.5 系列的数据,差异也极其悬殊:
| 模型与范围 | just-solve | anti_slop | 相对降幅 | Verbosity 增量 |
|---|---|---|---|---|
| GPT 5.3 Codex(原论文 36 题均值) | 0.64 | 0.42 | −34% | — |
| GPT 5.4(原论文 36 题均值) | 0.51 | 0.28 | −45% | — |
| GPT 5.5(原论文 36 题均值) | 0.49 | 0.21 | −57% | — |
Opus 5.5 forge 末关(本实验) | 0.69(首关 0.78) | 0.02(首关 0.00) | −97% | +0.10 vs. +0.03 |
Opus 5.5 circuit_eval 末关(本实验) | 0.74(首关 0.31) | 0.07(首关 0.00) | −91% | +0.11 vs. +0.01 |
两种提示词列报告 erosion,括号内为首关值;相对降幅以 just-solve 为基准。Verbosity 增量为末关 − 首关,依次为 just-solve vs. anti_slop。原论文行为 36 题均值,本实验行为对应题目的末关值。
这与原论文“显式质量提示词不改变退化速率(without affecting degradation rates)”的结论形成了鲜明对比。客观来看,造成这一反差的原因主要有两点:
- 模型代际差异:原论文测试
anti_slop仅使用了 GPT 5.3–5.5,而我们在 Claude Opus 5.5 上测试,强模型对长程架构指令的遵循能力可能存在明显差异。 - 指标截断与统计聚合偏差:
anti_slop要求“No god functions”,Opus 5.5 严格遵守指令将最高函数复杂度压在 10–12 附近,使得统计复杂度 > 10 的erosion接近于 0;而原论文在 36 题所有 Checkpoint 上求均值,大量早中期挂掉的轨迹与阈值跳变混合在一起,掩盖了长链路通关轨迹上斜率被压平的事实。
意外之喜:为什么写好代码反而帮 Agent 省了 39% 的钱?
原论文中有一句非常出圈的警句:“Slop does not fail your tests. It bills you.”(屎山不会挂掉你的测试,但会烧掉你的账单),同时原论文指出开启 anti_slop 会让每关成本平均增加 12.1%。
然而,当我们对比 circuit_eval 上四种策略跑完 8 关的真实账单时,却发现了一个极具工程启发意义的“复杂度—成本反转(Cost Crossover)”:
circuit_eval · 完整 8 关 · 复杂度与费用分别比较,均为越低越好
条形表示均值。定期重构仅 1 次运行,通过率为 90.5%;其他策略各 3 次运行。悬停或聚焦条形查看通过率与范围;原始表格保留在下方。
查看四种策略的原始数据
| 策略 | 次数 | C8 最高 CC | 通过率 | 费用($) |
|---|---|---|---|---|
1. 默认不重构 (just-solve) | 3 | 61.3 (47–75) | 99.8% | $21.40 |
| 2. 第 4 关后重构一次 | 3 | 34.3 (25–43) | 99.8% | $16.35 |
| 3. 第 2/4/6 关定期重构 | 1 | 42.0 | 90.5% | $43.58 |
4. 全程 anti_slop 约束 | 3 | 11.0 (10–12) | 99.6% | $13.12(省 39%) |
均为 circuit_eval 完整 8 关运行。最高 CC 与美元总费用报告均值,括号内为最高 CC 范围;定期重构仅运行一次,其余策略各三次。
为什么在简单题 forge 上 anti_slop 比 just-solve 贵($4.14 vs. $1.80),而在难题 circuit_eval 上 anti_slop 反而省了将近 40% 的钱($13.12 vs. $21.40)?
账单背后的经济学逻辑非常直观:
- 前期的“模块化基建费”:在简单题或前几关,
anti_slop需要拆分子文件、定义清晰的模块接口,这会带来一定的固定 Token 开销(Upfront Overhead)。 - 后期的“技术债高利贷”:在
circuit_eval这种长链路难题上,just-solve在前 4 关省下的抽象功夫,到了第 6–8 关变成了恐怖的认知负担。面对一个函数复杂度高达 50~75、长达数百行的巨型函数,Agent 为了塞进新特性而不破坏原有逻辑,必须在庞大的上下文中反复阅读、定位、跑测试、修 Bug,消耗了海量的 Context Token 与探索步数!
“从一开始就保持干净”不仅是为了人类可读,更是为了降低 Agent 自己在长程任务后期的推理与调试成本。
附带收获:给开源评测基准捉虫(Harness Issues)
在深入审查 150 多个 Checkpoint 的底层运行轨迹时,我们还揪出了 slop-code-bench 评测框架本身的 3 个底层 Bug(已起草上游 Issue):
-
pkill -f误杀 Agent 自身进程:框架通过命令行参数将完整题面 Prompt 传给claude。当 Agent 在沙盒内执行pkill -f <脚本名>清理后台进程时,如果脚本名恰好出现在题面文本中,会直接把容器内的 Agent 主进程自己杀掉,导致该关提前中断、Token 用量被记为 0 且had_error=False(159 个 Checkpoint 中发生了 7 次,我们在脚本中通过改为 stdin 传参彻底规避)。 - 重试机制漏记 Token 用量:当某关触发内部重试时,统计逻辑只记录最后一段的用量,导致费用与 Token 系统性偏低(5 个 Checkpoint 中最多一个漏记了 25 万输出 Token,我们的分析脚本通过累加全部
result事件进行了修正)。 - 重试直接覆盖原始轨迹:导致失败轮次的原始过程日志与开销记录永久丢失(例如 Opus 在
code_search第 3 关丢失了一次 $2.05 的运行记录)。
总结与工程启示
回顾这次对 SlopCodeBench 的复现与扩展实验,如果把核心结论浓缩成给 AI 辅助编程实践者的四条建议:
- 看清比例指标的盲区:评测代码腐烂时,不能只看
erosion等相对比例指标(易被新增小函数稀释),必须结合最高函数复杂度与高复杂度大函数的绝对个数。 - 不要指望 Agent 在做 Feature 时顺手帮你重构:在目标驱动且缺乏完整历史上下文的默认模式下,增量打补丁永远是阻力最小的路径(0/25 主动重构),这会导致分步迭代比全局生成多写出 20%–30% 的膨胀代码并淤积在入口函数中。
- 不要迷信“先堆功能、事后定期大重构”:没有完整上下文延续与严密测试兜底的阶段性大手术,不仅成本翻倍,还极易在后续迭代中因为跨文件架构陌生感引发回归错误(通过率从 99.8% 跌至 90.5%)。
- 把架构纪律写进第 0 天的 System Prompt / CLAUDE.md 里:在 Claude Opus 5.5 这一代强模型上,只要从第 1 关起就施加明确的模块化与函数复杂度约束(如“拒绝上帝函数、按职责拆分文件”),模型强大的路径依赖特性就会成为你的盟友——它不仅能把 8 关迭代的复杂度增量锁死在个位数,还能在复杂项目的深水区帮你省下近 40% 的 Token 账单。
局限性说明:本实验关于重构与 anti_slop 的核心结论基于 Claude Opus 5.5 在 forge 与 circuit_eval 两道代表性题目上的多次运行(多数条件每组 3 次,定期重构 1 次)。与原论文在 GPT 5.3–5.5 上结论的差异可能源于模型代际演进;后续工作将进一步扩展至更多模型与题库,并分离验证“代码结构优良”与“初始 Bug 更少”对后续演化的独立贡献。
参考资料:SlopCodeBench 论文(arXiv:2603.24755) · HTML 版 · 作者博客 · 项目主页 · NeurIPS 2026 · Hugging Face · Medium 讨论
引用
如果这篇文章对你有帮助,可以这样引用:
@misc{qin2026slopcode,
title = {是“不会设计”还是“懒得重构”?我们复现并解构了 SlopCodeBench 的代码腐烂之谜},
author = {Qin, Bowen},
year = {2026},
howpublished = {Blog post},
url = {https://eyuansu62.github.io/blog/2026/slopcodebench-cant-design-or-wont-refactor/}
}