是“不会设计”还是“懒得重构”?我们复现并解构了 SlopCodeBench 的代码腐烂之谜

SlopCodeBench 复现与五组对照实验

约 40 分钟 EN 中文

近期备受关注的 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)五组层层递进的实验,得出了截然不同的核心洞察:

  1. 指标假象(Metric Illusion):原论文的核心比例指标 erosion 存在严重的“分母稀释悖论”与“阈值截断效应”,单看该指标既会漏报真实的巨型函数膨胀,也会误判提示词干预的斜率。
  2. 分步迭代的代价是“代码膨胀与入口淤积”:在严格对齐全量回归测试集后,分步迭代相比一次性给全量需求的 One-Shot 会多写 20%–30% 的代码(p = 0.03)、耗时与费用翻倍,且复杂度高度淤积在入口函数 main() 中。
  3. 不是“不能”,而是“不愿”:在默认迭代中,Opus 5.5 在 25 次关卡转换中 0 次主动重构;但当我们单独下达“只重构”指令时,模型 6/6 次全部一次成功、测试零破坏,将单函数最高复杂度从 24–34 直接压回 8–13。所谓退化,本质是在“跨轮次失忆 + 隐藏历史测试”沙盒下的最小侵入式防御策略(Minimal-Invasive Patching)。
  4. 内生纪律完胜事后手术(且省钱 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 暴露历史回归测试集。

原论文通过大规模评测给出了三个相当悲观的论断:

  1. 迭代必然腐烂:77%–80% 的轨迹会出现结构侵蚀(Structural Erosion)和冗余膨胀(Verbosity),例如 Opus 4.7 在 forge 题目上的 main() 函数复杂度在 8 关内暴涨 7 倍(NeurIPS 2026)。
  2. 早期结构锁死命运:没有预设架构时,早期写坏的结构会被后续迭代不断放大。
  3. 提示词救不了退化斜率(最关键的结论):作者测试了要求模块化和限制函数大小的 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):

\[\mathrm{Erosion} = \frac{\sum_{f:\,\mathrm{CC}(f)>10} \mathrm{mass}(f)}{\sum_{f} \mathrm{mass}(f)}, \qquad \text{其中 } \mathrm{mass}(f) = \mathrm{CC}(f) \times \sqrt{\mathrm{SLOC}(f)}\]

作为一个带截断阈值的比例指标,它存在两个严重的测量盲区:

  1. 分母稀释悖论:在 code_search 第 3 关,Agent 一次性新增了 24 个极其简单的辅助小函数(复杂度仅 1~3)。这些小函数全部计入分母,瞬间稀释了高复杂度大函数的占比,制造出“结构侵蚀大幅好转”的假象。同理,如果算全项目的“平均函数复杂度”,也会被这批小函数拉低。
  2. 阈值截断效应(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. 全局一次性生成”的清晰图景:

  1. 分步迭代必然带来显著的代码膨胀(Code Bloat)与双倍成本:在实现完全相同需求的前提下,分步迭代比 One-Shot 多写 15%–30% 的代码(GLM 上平均多写 414 行,p = 0.03),且耗时与费用翻倍。
  2. 全局视野改变了“复杂度的淤积位置”:虽然两边高复杂度函数的总数相近,但在 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 提示词(要求拆分高复杂度函数、改善模块化,并保持现有行为不变):

查看重构前后原始数据
题目 次数 测试:重构前→后 最高 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)上,对四种策略进行了正面交锋:

  1. A 组(不重构 just-solve):全程默认提示词。
  2. D 组(中途重构一次):第 4 关后运行一次 refactor_only,第 5–8 关继续用 just-solve。
  3. P 组(定期重构):在第 2、4、6 关后各运行一次 refactor_only。
  4. 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 为末关。定期重构条件仅运行一次。

结果暴露了“定期外生重构”的三大硬伤:

  1. 末关剧烈反弹:在没有重构的最后一关,最高函数复杂度一关之内直接从 12 跳到了 42。
  2. 费用翻倍:总开销高达 $43.58,是不重构组($21.40)的整整 2 倍。
  3. 引发跨轮次回归错误(正确率从 99.8% 跌至 90.5%):第 8 关测试仅通过 512/566。排查轨迹发现,三次重构本身都没有改坏任何一行代码(重构前后测试通过数 100% 一致);真正翻车的是第 3 关——当第 2 关后的 refactor_only 会话把代码拆解成多文件结构后,第 3 关新空降的 just-solve Agent 面对陌生的跨文件调用链,在添加新功能时改坏了第 2 关的旧逻辑,且此后一直未能修复!“外生手术强加的抽象结构”与“下一关默认短视模式”之间发生了严重的认知断层。

发现 2:全程 anti_slop 彻底锁死退化斜率,直接反驳原论文结论!

最令人振奋的结果出现在 C 组(全程 anti_slop)。看看 circuit_eval 8 关下来每关最高函数复杂度的演化轨迹:

查看 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)”的结论形成了鲜明对比。客观来看,造成这一反差的原因主要有两点:

  1. 模型代际差异:原论文测试 anti_slop 仅使用了 GPT 5.3–5.5,而我们在 Claude Opus 5.5 上测试,强模型对长程架构指令的遵循能力可能存在明显差异。
  2. 指标截断与统计聚合偏差: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)”:

查看四种策略的原始数据
策略 次数 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):

  1. pkill -f 误杀 Agent 自身进程:框架通过命令行参数将完整题面 Prompt 传给 claude。当 Agent 在沙盒内执行 pkill -f <脚本名> 清理后台进程时,如果脚本名恰好出现在题面文本中,会直接把容器内的 Agent 主进程自己杀掉,导致该关提前中断、Token 用量被记为 0 且 had_error=False(159 个 Checkpoint 中发生了 7 次,我们在脚本中通过改为 stdin 传参彻底规避)。
  2. 重试机制漏记 Token 用量:当某关触发内部重试时,统计逻辑只记录最后一段的用量,导致费用与 Token 系统性偏低(5 个 Checkpoint 中最多一个漏记了 25 万输出 Token,我们的分析脚本通过累加全部 result 事件进行了修正)。
  3. 重试直接覆盖原始轨迹:导致失败轮次的原始过程日志与开销记录永久丢失(例如 Opus 在 code_search 第 3 关丢失了一次 $2.05 的运行记录)。

总结与工程启示

回顾这次对 SlopCodeBench 的复现与扩展实验,如果把核心结论浓缩成给 AI 辅助编程实践者的四条建议:

  1. 看清比例指标的盲区:评测代码腐烂时,不能只看 erosion 等相对比例指标(易被新增小函数稀释),必须结合最高函数复杂度与高复杂度大函数的绝对个数。
  2. 不要指望 Agent 在做 Feature 时顺手帮你重构:在目标驱动且缺乏完整历史上下文的默认模式下,增量打补丁永远是阻力最小的路径(0/25 主动重构),这会导致分步迭代比全局生成多写出 20%–30% 的膨胀代码并淤积在入口函数中。
  3. 不要迷信“先堆功能、事后定期大重构”:没有完整上下文延续与严密测试兜底的阶段性大手术,不仅成本翻倍,还极易在后续迭代中因为跨文件架构陌生感引发回归错误(通过率从 99.8% 跌至 90.5%)。
  4. 把架构纪律写进第 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/}
}