摘要
在长程编程基准 SlopCodeBench(每道题分 8 关逐步增加需求,每关在全新的隔离容器与新会话里启动,只保留工作区代码文件)上,我们此前观察到一个耐人寻味的现象:在默认的 just-solve(只要求过关)提示词下,Claude Opus 5.5 在连续 8 关迭代(共 25 次相邻关卡推进)中从未主动重构过代码,任由入口函数越写越长;但只要单独开一次会话要求它“别加新功能,只重构现有代码”,6 次尝试全部成功,测试一个没坏,最复杂函数的圈复杂度(即函数内 if/for/while 等分支路径的数量,下文统称复杂度)都能从 24–34 降到 8–13。更意外的是,如果从第 1 关就加上要求模块化的 anti_slop 提示词,8 关下来最高函数复杂度几乎不涨(仅 +0~+6,而默认模式暴涨 +14~+54),在难题 circuit_eval 上总花费反而比默认模式省了 39%($13.12 对 $21.40)。
为了弄清楚这只是个别题目的巧合,还是所有 Coding Agent 的共同特征,我们接着做了三项研究:
-
把“早期结构差”和“早期遗留 Bug”拆开测(第一节)
在forge第 3 关结束时,我们在 A 组(模型自然写出的单文件高复杂度代码,测试过 94.3/101)和 B 组(换成官方模块化参考答案,测试过 101/101)之间,补齐了第三种起点——B’ 组(在 A 组原函数内部打补丁把测试修到 101/101 满分,但完全保留原有的单文件高复杂度结构)。结果发现:在烂结构上把早期测试修到 100% 满分,对后 5 关少出新错毫无帮助——B’ 组和带旧 Bug 的 A 组在第 5–8 关挂掉了完全相同的19.0个新测试,且复杂度 $\ge 20$ 的大函数长到了5.0个(而好结构的 B 组只挂了5.3个测试,大函数仅1.3个)。 - 离线扫描 1.6 万条公开会话与 6,028 个全语言提交(第二节)
对 CodeMem(784 个关卡快照)、Thoughtworks / RouterBench / Finding-the-Right-Fit(1.6 万余条会话) 和 ProgramBench(591 个从零写项目的归档,共 6,028 个 Rust/Go/C/C++/Python 提交) 的静态分析表明:- 加“跨关记忆”管不住代码变乱:加上
ProjectMem项目记忆或保留full_trajectory完整历史后,36 道题的末关最高函数复杂度依然从首关的25.9涨到了49.8和52.1(极端函数涨到 206)。 - 单轮修 Bug 时,连人类程序员也是 0% 重构:在 45 道 SWE-bench Verified 同题配对中,面对高复杂度文件,人类开发者真实补丁(Gold Patch)的重构率同样是
0/23(0%),Opus 5.5 与 Fable 5.1 在 44/45(97.8%)道题上的复杂度变化与人类完全一致。单次修别人仓库时完全合理的“最小改动习惯”,被模型直接带进了需要长期演进的多轮开发里。 - 从零写完整项目也一样:用
lizard解锁 ProgramBench 中占 85% 的 Rust/Go/C/C++ 主力代码后,面对复杂度 $\ge 20$ 的高复杂度文件,Opus 5.5(3,852 次修改)、Fable 5.1(2,662 次) 和 GPT-6 Astra(447 次长会话修改) 确认抽出辅助函数的比例仅有0.31%、0.30%和0.22%(且全是在加新功能时顺手抽的,纯重构为 0);当直接修改一个已经复杂度 $\ge 20$ 的大函数时,Opus 5.5 和 Fable 5.1 有 53.9% 和 48.4% 的概率继续往里塞分支,最终写出的项目平均最高函数复杂度高达87.4 ~ 89.9。
- 加“跨关记忆”管不住代码变乱:加上
- 实测两套轻量解决办法(第三节)
除了“从第 1 关就用anti_slop提示词”之外,我们在 SlopCodeBench 上又实测了两种轻量办法:- G 组(每关结束前用脚本检查复杂度:
just-solve+ Claude CodeStophook):平时用默认提示词,避免在简单关卡过度拆文件;只在每关会话准备退出前自动用 AST 扫一遍,若发现有函数复杂度 $>15$,就拦住当前还没结束的会话让它当场拆小。在forge的 24 个关卡中一共拦截 13 次,每次拦 1 次就当场拆好,第 8 关最高复杂度从41.0压到13.7(复杂度 $\ge 20$ 函数数为0),费用只比默认多 19%($2.14 对 $1.80),比全程开anti_slop($4.14)省了一半。 - D+ 组(中途重构后留一份
CLAUDE.md说明):在circuit_eval第 4 关重构后的工作区根目录放一份写明模块职责和复杂度 $\le 12$ 要求的CLAUDE.md,后 4 关切回默认提示词。续跑的 12 个关卡最高复杂度全部保持在 $\le 13$,第 8 关停在10.3(通过率99.8%),彻底消除了不留说明时反弹回34.3的问题,run3在第 8 关甚至主动把新加的代码区段更新进了CLAUDE.md里。
- G 组(每关结束前用脚本检查复杂度:
附:实验中使用的三类核心 Prompt 精髓
在进入具体实验前,先列出我们在各组对照中使用的三个核心提示词(省略了虚拟环境 requirements.txt 等通用工程头尾,仅保留核心指令差异):
-
1.
just-solve(默认提示词 —— A 组全程,及 B / B’ / D / D+ 续跑、G 组使用)“Implement a program that 100% solves the specification. That is all you need to do. Your task is:
{{ spec }}“ -
2.
anti_slop(质量约束提示词 —— C 组全程使用)“You are an exceptional Python software engineer… Focus only on adding in the new features/changes below. Follow best coding practices: Group functions into files based on related functionality; Keep your code clean; No god functions/classes; Make sure the code is documented appropriately so that it is easy to pick up. Minimize the following gotchas: extra defensive checks, heavy nesting, if/else ladders, trivial wrappers, or a ton of helper methods. Your task is:
{{ spec }}“ -
3.
refactor_only(纯重构提示词 —— D 组第 4 关后单次重构、以及定期重构组使用,不含新规格说明)“The requirements for this program have not changed. Do not add any new features. Your task is to refactor the existing code in this directory to improve its structure: Break up large or deeply nested functions into smaller, focused ones; Remove duplicated logic; Organize the code so that it is easy to extend with new commands and features later. The program’s observable behavior (CLI, outputs, error messages and exit codes) must stay exactly the same. Before you finish, run the program on a range of inputs to verify that its behavior is unchanged.”
一、 起点实验:后续代码变乱,是因为早期结构差,还是因为早期有 Bug?
1.1 背景:A 组和 B 组是怎么做的?
在 SlopCodeBench 中,每道题分 8 个连续关卡(Checkpoint $1 \to 8$)逐步增加功能。每一关都在全新的容器和新会话里启动——上一关的聊天记录会被清空,只有工作区目录里的代码文件会保留到下一关。
在 8 关迭代题 forge 上,我们用 Claude Opus 5.5(Claude Code 2.1.44,默认 just-solve 提示词)先跑了两组对照(各跑 3 次):
- A 组(模型自己写的起点:单文件高复杂度 + 有少量旧 Bug)
- 做法:让模型从第 1 关自然跑到第 8 关,中途不加任何干预。
- 第 3 关结束时:所有代码都在 1 个单文件里,函数总数为
18 / 26 / 21个,最高函数复杂度已经到了32 / 29 / 28(平均29.7);第 3 关的 101 个测试分别过了95 / 93 / 95个(平均94.3/101,遗留了 6~8 个未通过测试)。 - 第 8 关结果:顺着跑到第 8 关,最高函数复杂度涨到
41.0(35, 39, 49),其中main()的复杂度达34.0,完整测试集通过率91.1%。
- B 组(换成参考答案起点:模块化好结构 + 100% 全对)
- 做法:把第 3 关结束时的代码替换成官方第 3 关参考答案(去掉 canary 标记),再从第 4 关开始用同样的
just-solve提示词续跑到第 8 关。因为每关都是新会话,模型无法区分代码是不是自己写的。 - 第 3 关结束时:参考答案拆了模块,最高函数复杂度只有
20.0(比 A 组低9.7),测试101 / 101全过。 - 第 8 关结果:换了起点后,第 8 关最高函数复杂度降到了
25.7(25, 26, 26)(与第 8 关官方参考答案的26基本持平),复杂度 $\ge 20$ 的大函数个数从 A 组的4.3个降到1.3个,通过率升到98.2%(比 A 组高出 +7.1pp)。
- 做法:把第 3 关结束时的代码替换成官方第 3 关参考答案(去掉 canary 标记),再从第 4 关开始用同样的
1.2 构造 B’ 组(烂结构 + 101/101 全过):分离“结构”与“旧 Bug”
B 组的参考答案起点同时占了“结构更好(最高复杂度 20.0 对 29.7)”和“Bug 更少(101/101 对 94.3/101)”两个便宜。为了把两者分离开,我们逐一检查了 A 组在第 3 关挂掉的那 6~8 个测试:
-
绝大多数不是逻辑 bug,而是报错文案格式问题:
name: must be...多了个冒号;invalid_operation的报错里写的是allocation id,没写出错的操作值。 -
只有
run2有一个真 bug:blueprints.json存成了dict,而测试要求是list。
我们把补丁全部写在 A 组原有的函数内部,构造出 B’ 组(烂结构 + 101/101 全对),严格满足四项检查:
-
第 3 关测试:从
95 / 93 / 95全部变为101 / 101; -
第 3 关最高函数复杂度:保持
32 / 29 / 28(平均29.7)不变; -
函数个数:保持
18 / 26 / 21不变; -
文件数:都是 1 个单文件。
forge · Claude Opus 5.5 · 每种起点运行 3 次。数值为完成第 8 关后、第 5–8 关测试的平均失败数。修复 Bug 后保留原结构;模块化代码采用官方参考实现,规格理解差异仍是潜在混淆变量。
从 B’ 组的 3 个快照续跑完第 4–8 关,三组结果对比如下:
| 指标(3 次运行平均) | A 组:烂结构 + 有旧 Bug (第 3 关 94.3/101) | B’ 组:烂结构 + 101/101 (在 A 组上原位修满测试) | B 组:好结构 + 101/101 (第 3 关换成参考答案) |
|---|---|---|---|
| 第 3 关起点:最高函数复杂度 | 29.7(32, 29, 28) | 29.7(32, 29, 28) | 20.0 |
| 第 8 关:最高函数复杂度 | 41.0(35, 39, 49) | 34.3(37, 34, 32) | 25.7(25, 26, 26) |
| 第 3 $\to$ 8 关:最高复杂度增量 | +11.3 | +4.7 | +5.7 |
| 第 8 关:复杂度 $\ge 20$ 的函数个数 | 4.3 | 5.0 | 1.3 |
第 8 关:main() 复杂度 | 34.0 | 24.3 | 19.0 |
| 第 8 关:完整测试集通过率 | 91.1% | 93.6% | 98.2% |
| 第 8 关:来自第 1–4 关的失败测试数 | 7.3 | 0.0 | 0.0 |
| 第 8 关:来自第 5–8 关的失败测试数 | 19.0 | 19.0 | 5.3 |
forge · Claude Opus 5.5 · 各组 3 次运行均值。两幅图使用独立量纲,条形均从零起;完整数据与起点条件见上表。
1.3 结论与局限
- 正确性的拆分很干净:B’ 组和 A 组在第 5–8 关的失败完全一样(都是
19.0个,连挂掉的测试都是同一批)。所以 A 到 B 的+7.1pp可以拆成两部分:- 约
+2.5pp来自前 3 关的旧 Bug:后续会话因为看不见前几关的测试,从来没修过它们,它们作为回归测试一直扣分到最后; - 约
+4.6pp来自参考答案起点让第 5–8 关的新失败更少(5.3对19.0):在烂结构上修满前 3 关的测试,对后几关少出新错没有帮助。
- 约
-
复杂度:起点的高低会一路延续下去:B’ 第 8 关的最高复杂度与 B 相差
8.6(34.3对25.7),和两者的起点差距(9.7)相近,且复杂度 $\ge 20$ 的大函数个数达5.0个(B 组仅1.3个)。不过 B’ 的最高复杂度增量(+4.7)和 B(+5.7)差不多,A 组那额外的膨胀没有重现:A 组 3 次里有 2 次在第 8 关继续往main()里堆分支,B’ 一次都没有。几处报错文案修改不太可能影响第 8 关的写法,所以这更像是 $n=3$ 下的随机波动,不能说成“修好 Bug 能抑制膨胀”;能站得住的说法是:末关复杂度的高低主要由起点结构决定。 -
还有一个混淆变量没分离开:B 组比 B’ 组多出的
+4.6pp不一定全是结构带来的。参考答案本身也包含对题目规格的准确理解(比如错误优先级和 UUID 校验的约定),这可能让第 6、7 关的测试更容易通过。 - Anthropic 报告的印证:为什么默认既不主动重构(
0/25),也不顺手修旧 Bug?Anthropic 在 Claude Fable 5.2 报告的《Prompting Guide》(”Say who owns the code”) 中提到:如果不说明代码归谁所有,模型倾向于把自己当“访客”,只在原有结构上添加代码(合并重复代码的比例 $<10\%$),发现附近的问题也只是报告出来;但如果明确告诉它“这个代码库由你负责维护”(“This codebase is yours: what it’s for and how it’s built are your call, and you’ll keep building on it”),它主动整理现有实现、合并重复代码的比例就会升到 约 50%,甚至顺手修复其他问题。
二、 公开数据离线实证:跨记忆、跨模型与 6,028 个全语言提交
为了检验上述现象在其他模型、框架和编程语言中是否成立,我们对三批公开轨迹归档进行了纯离线静态分析(固定数据集版本,不运行被分析代码、不调用任何推理 API)。
2.1 加上“跨关记忆”或保留“完整历史”,能消除结构退化吗?
在 zychen22/CodeMem-SCB-outputs(SlopCodeBench 全部 36 道 Python 题、784 个快照,glm-5.3-flash + mini_swe + just-solve)上对比四种记忆配置:
| 组别 | 题数 $N$ | 首关最高函数复杂度 (均值 / 中位数) | 末关最高函数复杂度 (均值 / 中位数) | 首末配对增量 (均值 / 中位数) | 最高复杂度上升的题数 | 高复杂度关卡($\ge 20$) 重构公式候选率 |
|---|---|---|---|---|---|---|
baseline(无记忆) | 36 | 25.92 / 24.50 | 43.22 / 38.50 | +17.31 / +11.00 | 31/36(86.11%) | 6/133(4.51%) |
ProjectMem(带作用域跨关记忆) | 36 | 25.94 / 21.50 | 49.81 / 39.50 | +23.86 / +12.50 | 29/36(80.56%) | 4/125(3.20%) |
full_trajectory(保留完整历史) | 35 | 25.91 / 24.00 | 52.09 / 49.00 | +26.17 / +23.00 | 34/35(97.14%) | 3/125(2.40%) |
memory_without_scope | 36 | 25.92 / 24.50 | 44.33 / 39.00 | +18.42 / +14.00 | 34/36(94.44%) | 4/132(3.03%) |
-
跨关记忆没有消除结构退化:加上
ProjectMem或保留full_trajectory后,末关最高复杂度均值反而升至49.81和52.09(人工核验确认基线至少 1/133、ProjectMem 至少 1/125 含结构抽取,但均伴随新功能开发)。典型膨胀案例如ProjectMem下sheeteval.py::grade_sheet从20 → 24 → 28 → 41 → 47 → 74 → 79(代码行数从 80 涨到 601),mocked_http的build_behavior_from_item从第 4 关的89一路涨到第 8 关的206。 -
单次长会话内部(Thoughtworks 1.5 万条会话):在 thoughtworks/agentic-coding-trajectories 严格还原的 500 条长会话(轮数 $\ge 30$、同一函数至少修改 3 次,共 684 条函数序列、3,013 次函数修改,涵盖
swe-agent与openhands) 中:- 88.58%(2,669 / 3,013) 的修改步复杂度非下降(其中 55.23% 持平、33.36% 增加、11.42% 下降),表现为明显的非下降倾向,但并非每步都在增加分支(如
sunpy的XRSTimeSeries.observatory连续修改 15 次从复杂度 8 升至 53); - 在修改前文件最高复杂度 $\ge 20$ 的 592 次编辑中,满足重构公式的候选为 4/592(0.68%),经逐段阅读代码确认真正将逻辑移入辅助函数的仅有 3 / 592(0.51%)(另外 1 例为保留两份实现的兼容分流);若要求被修改的函数本身在修改前复杂度已达 $\ge 20$(共 380 次编辑),则有 43.16%(164/380) 继续增加该函数的复杂度,确认抽取率为 3 / 380(0.79%)。
- 88.58%(2,669 / 3,013) 的修改步复杂度非下降(其中 55.23% 持平、33.36% 增加、11.42% 下降),表现为明显的非下降倾向,但并非每步都在增加分支(如
2.2 三大旗舰模型(Opus 5.5 / Fable 5.1 / GPT-6 Astra)与人类 Gold Patch 对照
在 RouterBench、Finding the Right Fit 以及两个原生 Fable 5 日志库(日志一、日志二)中:
- 高复杂度文件再次被编辑时的表现:
- 在排除测试路径的高复杂度($\ge 20$)文件编辑中,Opus 5.5(0/14)、Fable 5.1(0/5)、Fable 5(0/9)均为零命中;GPT-6 Astra 在 447 次高复杂度编辑中仅命中 1 次(0.22%)(
vllm流式解析器复杂度从41降至12,抽出了_streaming_content并伴随累计文本解析算法重写;而在较低复杂度 $14\sim 16$ 区间,Astra 另有 4 次在修功能的同时抽出了辅助函数)。当直接修改一个原复杂度 $\ge 20$ 的函数本体时,Astra 有 35.35%(76/215) 继续加分支。 - 在 Astra 的 57 个严格长会话(101 个函数序列、457 次函数编辑) 中,92.12%(421/457) 的编辑步复杂度非下降(例如
simglucose控制器SubmissionController.act经 13 次修改从复杂度32一度微调至25,随后升至59;金融任务fin-saccr-rwa的main()在复杂度98连续修改 7 次保持停滞)。
- 在排除测试路径的高复杂度($\ge 20$)文件编辑中,Opus 5.5(0/14)、Fable 5.1(0/5)、Fable 5(0/9)均为零命中;GPT-6 Astra 在 447 次高复杂度编辑中仅命中 1 次(0.22%)(
- SWE-bench 同题配对:修单轮 Bug 时,连人类开发者也是 0% 重构: 在 45 道完全相同的 SWE-bench Verified 题目上,对比 Opus 5.5、Fable 5.1 与人类开发者真实合并的 Gold Patch(取三者修改的非测试 Python 文件并集):
| 参与者(同一批 45 道 SWE-bench 题) | 题数 $N$ | 最高复杂度变化(均值 / 中位数) | 函数数增加的题数 | 最高复杂度上升题数 | 高复杂度($\ge 20$)文件上的 重构公式命中率 |
|---|---|---|---|---|---|
| Claude Opus 5.5 | 45 | +0.089 / 0.000 | 21/45(46.67%) | 4/45(8.89%) | 0 / 23(0.00%) |
| Claude Fable 5.1 | 45 | +0.089 / 0.000 | 21/45(46.67%) | 4/45(8.89%) | 0 / 23(0.00%) |
| 人类开发者(Gold Patch) | 45 | +0.067 / 0.000 | 21/45(46.67%) | 3/45(6.67%) | 0 / 23(0.00%) |
-
两模型各有 44/45(97.78%) 的共享范围最高复杂度变化与人类 Gold Patch 完全相同;面对高复杂度文件,人类 Gold Patch 同样是
0/23零重构(例如在django__django-15629中,面对原本复杂度就高达79的_alter_field函数,人类、Opus 5.5 和 Fable 5.1 全都在原函数里加了 2 个分支变成81)。 -
启示:在单轮修复成熟大仓库的 Issue 时,不动周围结构、只打最小补丁本来就是人类工程师的标准做法;但当模型把这套单步修补习惯带进多轮迭代或从零建库时,就会不断累积分支。
2.3 那如果让模型“从零写自己的项目(Rust / Go / C++)”呢?
看到 2.2 节的 SWE-bench 结果,很自然会有一个疑问:“在 SWE-bench 里不重构,是因为那是别人的旧仓库、且都是 Python 代码;如果让模型从空白目录开始写它自己的新项目(拥有 100% 代码所有权),或者换成 Rust、Go、C++ 这类系统级语言,它还会一直堆大函数吗?”
为了检验这一点,我们用多语言复杂度工具 lizard lizard 官方说明 扫描了 ProgramBench 上三大模型从零构建的 591 个完整项目、6,028 个第一父链 Git 提交(Opus 5.5 195 题 / 3,504 个提交、Fable 5.1 196 题 / 2,119 个提交、GPT-6 Astra 200 题 / 405 个提交;其中 Opus 5.5 和 Fable 5.1 在 90% 以上的项目里使用了 Rust、Go、C/C++):
| 模型(ProgramBench 全语言提交) | 首末有效配对项目 $N$ | 首末最高复杂度增量 (均值 / 中位数) | $\ge 3$ 次同函数修改 复杂度非下降比例 | 修改前最高复杂度 $\ge 20$ 的 文件修改数 | 重构公式候选 ( RefactorProxy) | 人工确认含辅助函数抽取 (全部伴随功能改动,纯重构=0) | 直接修改复杂度 $\ge 20$ 函数本体时 继续加分支的比例 |
|---|---|---|---|---|---|---|---|
| Claude Opus 5.5 | 185 | +16.71 / +2.00 | 2,148 / 2,382(90.18%) | 3,852 | 20(0.52%) | 12 / 3,852(0.31%) | 1,342 / 2,490(53.90%) |
| Claude Fable 5.1 | 167 | +15.83 / 0.00 | 1,093 / 1,242(88.00%) | 2,662 | 14(0.53%) | 8 / 2,662(0.30%) | 916 / 1,892(48.41%) |
| GPT-6 Astra (极少中间 commit) | 3 | 0.00 / 0.00 | 0 / 0(NA) | 4 | 0(0.00%) | 0 / 4(0.00%) | 0 / 3(0.00%) |
结果非常明确:哪怕没有历史包袱、从零写自己名下的 Rust / Go / C++ 项目,模型依然保持了几乎一模一样的“只加分支、不拆函数”惯性——每当 Opus 5.5 和 Fable 5.1 回头修改一个自己写的、复杂度已经 $\ge 20$ 的大函数时,分别有 53.90% 和 48.41% 的修改继续往该函数里塞分支;而在全部 6,518 次高复杂度文件修改中,人工核对确认抽出了辅助函数的只占 0.31% 和 0.30%(且全都是在加新功能时顺带抽的,纯重构为 0)。到项目写完时,三个模型的单项目最高函数复杂度均值都达到了 87.4 ~ 89.8(例如 Opus 5.5 用 C 写 calcurse 时把 ui_main 的复杂度从 1 连续 11 次提交单调塞到 93,用 Rust 写 nsh 时把 run 从 2 塞到 101;Fable 5.1 用 Rust 写 broot 时把 execute_internal 从 168 塞到 242)。
三、 为什么模型默认不重构,以及两种轻量治理方案的实测
3.1 三个核心原因
-
旧代码本身就是给下一轮看的示范:每关清空对话后,下一轮模型只能看工作区里的代码。留下一坨单文件大函数(哪怕像 B’ 组那样 101/101 无 Bug),下一轮就会顺着往里塞分支;而如果中途在外部强拆多文件(如每 2 关定期重构)却不留模块说明,下一轮模型又容易在跨文件修改时改坏旧功能(通过率跌至
90.5%)。 -
局部视角下,“只加分支、不动旧结构”最安全:在看不见前几关回归测试、也未被声明“代码归你负责”时,重构旧函数的当期风险高,顺手加个
elif最省事,只是把阅读与维护成本留给了后几关。 -
复杂函数必须在当前会话结束前拆掉:一旦函数带着 $\ge 20$ 的高复杂度跨过会话边界保存下来,后续会话主动拆它的概率不足
0.5%,而继续加分支的概率接近一半。
3.2 两种轻量治理方案的实测结果(G 组与 D+ 组)
我们在“从第 1 关全程用 anti_slop 提示词(C 组)”之外,在 Claude Opus 5.5 上实测了另外两种方案:
1. G 组:forge 上的会话内门禁(just-solve + Stop hook)
平时使用默认 just-solve 提示词,避免前几关过度模块化;将门禁脚本(scripts/ast_stop_gatekeeper.py,阈值设为复杂度 $\le 15$)挂载在 harness 的用户级 ~/.claude/settings.json 中(对应配置 claude_code-2.1.44-astgate,这样工作区快照不会出现 .claude/ 目录,无需每关清理;拦截计数按会话 ID 记录,防止容器跨关存活时串计数)。
forge 第 8 关(3 次平均) | A 组:默认 just-solve | G 组:just-solve + 门禁 | C 组:全程 anti_slop |
|---|---|---|---|
| 最高函数复杂度 | 41.0 | 13.7(13, 14, 14) | 10.0 |
| 复杂度 $\ge 20$ 的函数数 | 4.3 | 0 | 0 |
erosion(首关 $\to$ 末关) | 0.78 $\to$ 0.69 | 0.12 $\to$ 0.17 | 0.00 $\to$ 0.02 |
| 通过率 | 91.1% | 91.5% | 92.1% |
| 费用 | $1.80 | $2.14(+19%) | $4.14(+130%) |
Claude Opus 5.5 · 各组 3 次运行均值。通过率分别为 91.1%、91.5%、92.1%;复杂度与费用各自使用独立刻度。
-
拦 1 次就能当场拆好:24 个 checkpoint 中门禁一共拦截了 13 次,被拦下的正是第 1 节里原本会一路膨胀的那几个函数(如早期的
alloc_bind复杂度 25–28,以及后几关的main/run复杂度 17–21)。每次都是拦 1 次后当前会话就当场把函数拆好了,从没碰到“拦 2 次后放行”的上限。 -
费用仅多 19%,省去了前期过度模块化的浪费:G 组复杂度接近
anti_slop,但全程保持单文件,费用只比默认多 19%($2.14),比全程anti_slop($4.14)便宜了近一半。 -
需要注意:末关复杂度 $\le 15$ 有一部分是门禁直接规定的结果,不能全算作模型自觉。
2. D+ 组:circuit_eval 上的第 4 关重构 + CLAUDE.md
在 D 组第 4 关重构后的工作区根目录放一份 CLAUDE.md(写明模块职责划分与“函数复杂度 $\le 12$”要求,已验证 --print 模式下会被自动加载),第 5–8 关继续用默认 just-solve 续跑:
circuit_eval 第 8 关(3 次平均) | A 组:不重构 | D 组:第 4 关重构一次 | D+ 组:第 4 关重构 + CLAUDE.md | C 组:全程 anti_slop |
|---|---|---|---|---|
| 最高函数复杂度 | 61.3 | 34.3 | 10.3(11, 10, 10) | 11.0 |
| 复杂度 $\ge 20$ 的函数数 | 8.0 | 5.0 | 0 | 0 |
erosion(首关 $\to$ 末关) | 0.31 $\to$ 0.74 | 0.31 $\to$ 0.52 | 0.31 $\to$ 0.01 | 0.00 $\to$ 0.07 |
| 通过率 | 99.8% | 99.8% | 99.8% | 99.6% |
| 费用 | $21.40 | $16.35 | ~$16.40 (含超时关估算) | $13.12 |
Claude Opus 5.5 · 各组 3 次运行均值。D+ 费用约 $16.40,含超时关估算,以浅色虚线标记;通过率见上表。
-
彻底压住了重构后的反弹:D 组从第 5 关就开始反弹,到第 8 关涨回
34.3;而 D+ 组续跑的 12 个 checkpoint 最高复杂度 全部 $\le 13$,第 8 关停在10.3,与全程anti_slop(11.0)持平。run3在第 8 关还主动把新加的代码区段补进了CLAUDE.md的模块职责图里。 -
费用与局限:
run2第 8 关跑了 2.7 小时触发超时(代码在超时前已写完,快照为566/566全过、最高复杂度 10,因此复杂度和通过率有效,但轨迹里费用记为$0);用checkpoint_results.jsonl里的估算($11.99)补上后,D+ 组平均约$16.40,与 D 组的$16.35持平,没有比全程anti_slop($13.12)便宜。此外,D+ 和 D 有两处不同(一是有模块结构说明,二是CLAUDE.md里写了复杂度 $\le 12$ 这个数字),本实验分不清是哪一个起了主要作用。
四、 实用选型建议
-
已知复杂的长线任务(如
circuit_eval):直接从第 1 关加上质量提示词(anti_slop),效果最好且最省钱(省 39%); -
中小型或事先不确定难度的任务(如
forge):用默认提示词配合Stophook 在每关结束前检查复杂度(G 组),超标时让当前会话当场拆小,只多花 19% 就能防住函数膨胀; -
中途重构或接手已有项目(如 D+ 组):重构完务必在工作区留一份
CLAUDE.md写明模块职责与复杂度上限,防止后续会话重新把代码写乱。
引用
如果这篇文章对你有帮助,可以这样引用:
@misc{qin2026codeerosion,
title = {为什么再强的 Coding Agent 也会把代码写成“屎山”?},
author = {Qin, Bowen},
year = {2026},
howpublished = {Blog post},
url = {https://eyuansu62.github.io/blog/2026/coding-agent-code-erosion-counterfactuals-and-governance/}
}