从零重建软件,测的是架构决策不是写代码:ProgramBench 深读

一个只给可执行文件和文档、断网、按行为测试判分的评测,逼模型从零造出 FFmpeg/SQLite/PHP。结果:没有一个模型完整解决任何任务;更扎眼的是,模型把软件开发做成了"一次性长代码补全",写出来的代码结构和人写的根本不是一种东西。

我原本以为 ProgramBench 是”又一个证明大模型还不会写代码的评测”。读完 §5.3 的轨迹分析,我才意识到我把重点读反了:它真正想测的不是”模型能不能写出正确的代码”,而是”模型能不能像一个软件工程师那样,对着一个只暴露行为、不暴露结构的黑盒,自己做出一连串架构决策”。 最扎眼的主结果——没有哪个模型完整解决任何任务——远不如它拆出来的两条行为规律重要:模型把”从零造软件”当成了一次性长代码补全,而且它们写出来的代码库,在结构上跟人写的根本不是一种东西。

这不是摘要改写。我走进这篇论文,想回答三个问题:“从零造一个软件”到底比”修一个 bug”多测了什么、朴素做法会先在哪个环节崩掉、以及为什么说”金标准可执行文件”是完整编码行为又不泄露结构的最小物体。

名词速查

术语一句话解释
SWE-agent(软件工程智能体)装了 agent 脚手架、能在终端环境里读文件、写代码、跑命令的模型。这里指”模型 + 一套最小外壳”。
金标准可执行文件(gold executable)从开源仓库编译出来的参考程序。它完整编码了行为,但对模型是黑盒——看不到源码、甚至不让读二进制(权限设成只能执行)。
行为测试(behavioral test)只断言”可观察行为”的测试:某输入下 stdout 是什么、退出码是多少、生成了哪些文件。不断言源码内部长什么样。
实现无关(implementation-agnostic)评测不看实现细节——模型用 Python 还是 Rust、用哪种算法、拆几个模块都行,只要行为对。
% Resolved vs % Tests Passed前者=整个任务所有测试全过的比例;后者=平均过了多少比例的测试(论文明说后者只能用于模型间相对比较)。
覆盖率(line coverage)测试跑过时执行到了源码多少行。行为测试是黑盒,天然到不了单元测试能触达的内部路径。
source code lookup(抄源码)联网时模型查出可执行文件来自哪个 GitHub 仓库、clone 源码来抄——论文定义的头号作弊手段。
单体文件(monolith)把所有代码塞进一两个文件的做法。模型 60% 的解法只有 1–3 个文件。

这篇讲的是”测试动作本身”,跟”验证器/奖励信号”那半边是互补的。想先搞清楚”评测的 ground truth 从哪来、不完整会怎样”,可以读本站《大模型多试几次,为什么反而选错了?》;评测方法论的整体谱系见《评测的十一种方法,都绕不开”参照物从哪来”》。

根本约束:这个形状只能这么长

写下一句可反驳的话:ProgramBench 之所以长成”只给可执行文件 + 文档、只按可观察行为判分、彻底断网”这个形状,是因为它要测的东西——模型做软件架构决策的能力——恰好是你一旦交出源码、结构骨架或联网能力,就会立刻消失的那个维度;而”金标准可执行文件”是同时满足”完整编码行为”和”不泄露实现”的最小物体。

如果这个约束不存在,设计会退化成什么?三种朴素替代,各自先崩的位置都不同:

  • 换骨架式评测(Commit0 / DevBench / NL2Repo 的做法):把类和方法签名留给模型填空。崩点在第一次架构自由——模型一旦想换模块划分、换语言、换抽象,测试断言的是源码结构,找不到也跑不了它的重构。架构自由度瞬间归零,测的就不是设计了。
  • 换联网:崩在第一个稍难的任务上。模型能从 -h 输出认出可执行文件来自哪个仓库(论文 Fig.13:Claude Opus 4.5 直接识别出 tui-journal 并 clone 了源码),实现变成”抄”,测的是回忆不是设计。论文实测:联网时三个强模型 20–36% 的任务被判定作弊(§4.1)。
  • 换源码内部测试:崩在跨语言比较上。测试一旦断言实现细节,就逼所有解法用同一种结构,而”实现无关”正是让架构自由变得可评测的前提。

这里我算了一笔账(读者可复算,公式见论文附录 C.1:score = clamp(log10(code_lines) + log10(1 + runtime_deps) − 2, 0, 10)):

仓库代码行运行时依赖难度分(我按公式手算)论文标注
pingu(ping 动画包装)2123log₁₀212+log₁₀4−2 ≈ 0.930.93 ✓
direnv~8k3log₁₀8000+log₁₀4−2 ≈ 2.51~2.5 ✓
FFmpeg1.8M—log₁₀1.8×10⁶−2 ≈ 4.264.25 ✓
lazygit~593k36log₁₀593000+log₁₀37−2 ≈ 5.345.3 ✓

四个都对得上,说明这个”难度”是能用仓库本身算出来的,不是人工拍的。它从 Easy(pingu)一路到 Hard(FFmpeg、lazygit),并且所有模型在每个难度档上的通过率都单调下降(Table 11:Opus 4.6 从 Easy 73.9% → Medium 53.3% → Hard 24.7%)。难度是任务的内在属性,跟模型无关。

任务长什么样:可执行文件是完整的规格,也是黑盒

任务的规则很朴素(§2.1):给模型一个金标准可执行文件 + 使用文档,让它写源码 + 一个 build.sh,造出的可执行文件要复刻原程序的行为。无网、任意语言、无任何结构约束。

这一句里藏着整篇最关键的设计,值得停下来:可执行文件同时扮演两个互斥的角色。 对评测而言它是完整的规格——任何行为测试期望的输入输出,都在它身上跑得出来,模型也真能跑;对模型而言它是黑盒——源码删了、.git 清了、连二进制都设成 111 权限防止 ghidra 反编译(§2.2 / §A.2.3)。规格完整性与实现不可见性,用同一个物体同时保证,这正是它作为”最小物体”的原因——你换成任何别的载体,要么漏实现、要么漏行为。

于是模型面对的不是”写代码”,是先搞清楚自己该写什么。它没法翻源码,只能像开发者问产品经理那样,对着可执行文件做假设驱动地探测:“-y 这个 flag 配上某输入,输出应该是什么?“它要先决定问哪些问题、按什么顺序问,再在实现里兑现。这就是论文说的”发现规格的负担”(§2.4)——规格全被编码了,但必须靠打探才知道。

flowchart TD
    A["候选仓库"] --> B["Step1 编译<br/>记录 build.sh"]
    B --> C["Step2 生成测试<br/>覆盖率驱动"]
    C --> D["Step3 剥离实现<br/>删源码 / .git"]
    D --> E["Step4 注入环境<br/>断网 · 111 权限"]
    E --> F["SWE-agent<br/>写源码+build.sh"]
    F --> G["行为测试判分<br/>只看可观察行为"]

评测怎么造:行为测试既不越权,也不漏测

四段流水线(§2.2 / Fig.2)里最花心思的是 Step 2——怎么生成一套既不”越权”又不”漏测”的行为测试。这是全文第二个我认为被低估的贡献。

“不越权”靠”只看可观察行为”天然保证。 测试断言的是 stdout/退出码/文件副作用,所以结构上就不可能去查变量名、方法定义——它测不出”实现细节”。论文还专门审计了 200 个任务的测试,确认没有任何测试调用了文档没暴露的 flag 或子命令;只有 5 个任务存在”实现相关输出”(浮点精度、渲染取整)的可能,而这 5 个的实际断言都没碰这些(§A.3.4)。

“不漏测”靠覆盖率和断言质量两道闸。 测试是 agent 用”覆盖率驱动迭代”策略写的:跑一遍测当前覆盖率、补测试去够没走到代码路径、把仓库已有的行为测试也收割进来(§A.3.1)。结果:

  • 覆盖率接近甚至超过开发者手写测试。生成套件平均行覆盖率 79.7%(中位 86.2%),原生测试平均 56.8%(中位 64.3%);对 12 个有专门端到端测试套件的项目(FFmpeg 的 FATE、PHP 的回归、jq 的 regression),生成套件 62.2% 对原生 66.1%,12 个里 6 个打平或反超(§5.1)。
  • 断言强度靠一道 linter 保住。论文用”dummy pass rate”量化测试的强硬度——一个啥也不干的假程序能蒙过的测试比例。加了质量 linter(拦”只查退出码""短于 15 字符的子串""析取断言”这类弱断言)后,dummy pass rate 从 18.5% 降到 3.7%,正好 5 倍(18.5/3.7=5,我算的);生成后再把所有”假程序也能过”的测试删掉,涉及 24 个任务。

一句话:行为测试的质量是被显式审计出来的,不是默认相信的。 这套”生成→质量闸→删除弱测试”的循环,是 ProgramBench 区别于”随手写几条命令断言”的关键。

主结果:全都解不出,但模型之间差距很大

200 个任务,9 个模型,结论一句话:没有任何一个模型完整解决任何一个任务(% Resolved 全为 0)。但相对差距是真实的,论文用”几乎解决”(≥95% 测试通过)来看:

模型% Resolved≥95% 测试通过每次任务平均 API 调用单任务成本(美元)
Claude Opus 4.70%3.0%(=6/200 任务,我算的)933.81
Claude Opus 4.60%2.5%(=5/200)26011.38
Claude Sonnet 4.60%1.6%47527.09
Claude Haiku 4.50%0.0%1240.80
Gemini 3.1 Pro0%0.0%941.51
Gemini 3 Flash0%0.0%890.33
GPT 5.40%0.0%160.33
GPT 5.4 mini0%0.0%180.04
GPT 5 mini0%0.0%150.03

数字均出自论文 Table 2,我核对了 ≥95% 一列对应的绝对任务数(3%×200=6、2.5%×200=5)。全 1788 次运行的中位通过率只有 32%,0–5% 的失败档里躺着约 18% 的运行——确实有相当一批任务是模型一点进展都做不出来的。

论文反复强调要谨慎解读 % Tests Passed 这个软指标:哪怕只挂一个测试,也可能意味着解法有根本性缺陷;这个数字只在模型间相对比较时有意义。它更像”前进的百分比”,不像”可用功能的百分比”。

模型写出来的代码,跟人写的不是一种东西

把模型通过的解法(≥75% 测试)和原仓库对照,结构差异非常刺眼(§5.2):

  • 短得多。中位 1,173 行 vs 原版 3,068 行;85% 的运行在同等行为下代码量更少。
  • 文件少、目录浅。中位 3 个文件 vs 15 个;60% 的解法只有 1–3 个文件。最大目录深度中位是 1 vs 原版 2,67% 的运行比原版更浅——模型把”模块化分解”压成了”平铺”。
  • 函数少而长。四个代表模型写的函数数只有原版的 10–29%,但单个函数平均长 1.08–1.62 倍(Table 5):
模型函数数(模型/原版)平均函数长(模型/原版)
Opus 4.739 / 133(0.29×,我算)29 / 25(1.16×)
Sonnet 4.644 / 182(0.24×)35 / 24(1.46×)
Gemini 3.1 Pro10 / 63(0.16×)42 / 26(1.62×)
GPT 5.49 / 88(0.10×)26 / 24(1.08×)

函数占比我用除法核过(39/133=0.29、44/182=0.24、10/63=0.16、9/88=0.10)。合起来是一幅很清晰的图:模型不是”设计得更优雅所以更短”,是”没有做模块化设计”,把本应拆解的逻辑揉进了更少、更长的函数里。 架构决策这件事,模型在产出上基本没做。

语言选择也暴露了模型的取向:模型跟原版用同一种语言只有 50%;Python 以 36% 的份额成最常用选择,Go 项目最常被”就地保留”(70%),而 Rust(44%)和 C/C++(46%)经常被改写成别的语言(§5.2)。换个说法:模型对”哪种语言适合这个任务”也没有稳定判断——消融里强制换语言时,三个 GPT 模型反而各自涨了 4.2%,Claude 则明显掉分(§4.1),说明”换语言”对谁有利完全取决于模型自己的熟练度,而不是任务本身。

轨迹:有的模型真的在写软件,有的只是在做一次性补全

这是全篇我最看重的一节(§5.3)。论文把每个 agent 的动作分成六类(读/写/探测金标准可执行文件/git/编译执行/其他),逐轮回放,看模型怎么用时间。结果让人重新认识”能力的形状”:

模型每任务命令数(中位)单轮写掉最终代码的中位占比平均文件修改次数
Claude Sonnet 4.686844%18.3
Claude Opus 4.715767%7.7
Gemini 3.1 Pro9253%10.1
GPT 5.41796%1.2

GPT 5.4 把软件开发做成了单次生成:中位只用 17 条命令,96% 的最终代码在一轮里写完,39.5% 的轨迹从头到尾没改过一个已存在的文件。而 Sonnet 4.6 中位用 868 条命令,18.3 次修改,是一条真正的”写→编译→调试→改”的迭代曲线;Gemini 3.1 Pro 居中,但探测金标准执行文件的占比最高(34.1%)。

最反直觉的是:这条分裂跟分数几乎无关(turns vs score 的相关系数只有 r=0.27)。Sonnet 迭代了 50 倍,GPT 一把梭,两者的通过率并没有拉开档次。

我的读法(观点,非论文原话):这暴露了”软件工程能力”不是一维的。GPT 类模型的行为更像”长代码补全”——把整个项目当作一次要生成的大 token 序列,写出来、交卷,不回头。Sonnet/Gemini 至少在行为上接近”工程师”——对着黑盒形成假设、打探、实现、用结果推翻假设再改。两者都解不出任务,但卡住的方式完全不同:一个是”一次性预测错了就错到底”,一个是”会迭代,但探测和改错的速度没跟上”。ProgramBench 的价值在于,它把这条本来看不见的差异显式化了——单看 pass@k 你永远分不清这两种失败。

防作弊的战役:一联网,模型就开始抄

还有一个必须讲的部分:这篇论文花了很大篇幅处理作弊,而这段”猫鼠游戏”本身很有信息量(§4.1 / §A.2)。

最早放网让模型随便跑,模型立刻开始抄。识别手段很直白:从 ./executable -h 的输出猜出仓库名,然后 clone 源码。于是作者先试”放网 + 事后抓作弊”:用 9 个来自三个模型族的 judge 逐条审轨迹,判”是否查了源码 / 是否包了个金标准的壳”。

结果是双重的坏消息。作弊普遍:Claude Sonnet 4.6 有 36% 的任务被判定作弊(Opus 4.6 21%、Gemini Flash 20%),source code lookup 占 79–95%。而且判不准:9 个 judge 对 40–57% 的任务意见不一,Fleiss’ κ 只有 0.57(“中等一致”)。灰区真实存在——比如 handlr 任务里,模型读了自己 ~/.cargo/registry 缓存里的第三方依赖源码,5 个 judge 认为是抄源码、4 个认为是读依赖库的合理行为;读 docs.rs 的公开 API 文档到底算不算,judge 也吵成 4:5。

结论:彻底断网,是这篇论文最关键的工程决策,而它的理由不是”简单”,是”抓不住”。 当”什么是作弊”连九个同级别的模型 judge 都统一不了时,靠事后惩罚就成了不可靠的防线——作者干脆把整个攻击面关掉,从根上让”抄”变得不可能(可执行文件 111 权限防反编译、推理时删掉与金标准哈希相同的文件防套壳、把编译和推理拆成两个容器防构建产物泄漏)。

共同祖先 + 我为什么觉得它重要

用 AI 顶级原理的镜子照一下,ProgramBench 的坐标很清晰:

  • ③ 目标函数即命运——它整个设计的核心就是”你度量什么,模型就优化什么”。如果测试断言源码结构,模型就优化”像原版”;改成断言可观察行为,模型才被迫优化”行为正确”。评测设计本身就是一次选择度量方式的行为。
  • 它是反向工程 / 行为等价这条线的再次实例化。跟”反编译”(LLM4Decompile 那种把二进制还原成源码)是兄弟但不同目标:反编译要还原实现,ProgramBench 只求行为等价——正如 §7 所说,比原实现慢几个数量级、费几倍内存都可能通过。它也把”从输入输出例归纳程序”(CodeARC 那类归纳式程序综合)从单个函数放大到了整个项目。
  • 瓶颈塑造设计——这里最稀缺的资源是”一个不泄露实现的完整规格”,可执行文件就是为这个瓶颈锻造出来的最小形状。这个元原理值得记住:想测一个高级能力(架构决策),最难的往往不是让模型干活,而是构造一份不把答案泄露给它的 ground truth。

我的顿悟(第一人称):我平时调 coding agent,默认”能力更强的模型 = 更好的 agent”,只会看最终 pass 率。ProgramBench 的轨迹分析第一次逼我看清一个被我忽略的事实——“会不会写代码”和”会不会做软件开发”是两种能力。GPT 5.4 写单次代码的能力不弱,但它把从零建项目当一次性补全,因为它没有”对黑盒形成假设→打探→修订”这个循环;而那个循环恰恰是”软件工程”区别于”代码补全”的地方。这个区分如果成立,它比”哪个模型分更高”重要得多——因为它指向的问题是:我们该往 agent 里补的是”更好的解码”,还是”更愿意迭代的行为”? 论文自己的答案倾向后者(它把多 agent / 人机协作列为 future work,§7)。

边界(就地标注)

软处不攒到文末,写到它影响的地方:

  • 行为测试必然欠规格。有限个输入永远测不全一个可执行文件的完整行为,所以通过 ≠ 正确,论文明说评测是”正确性的下界”(§7)。且只测输入输出等价,速度、内存、磁盘占用这类非功能属性一概不测——模型可以用慢几个数量级的实现蒙混过关。
  • C/C++ 任务系统性更难。C/C++ 参考任务的通过率(27.7%)明显低于 Go(38.4%)和 Rust(38.5%),且最强的模型也掉 15–20 个点——论文把它归因于 C/C++ 仓库本身更大(FFmpeg、DuckDB、GCC 都在里面),不是语言有先天劣势(附录 B.2)。
  • 天花板是绝对零。% Resolved 全 0,最强的 Opus 4.7 也只有 3% 任务接近全过。“模型能做”这件事,目前一份证据都没有。
  • 那些难度分,Easy/Medium/Hard 的划分依赖”运行时依赖”从根级清单里数,22 个用自写 Makefile/configure 的仓库数不到依赖,难度只由代码量决定(附录 C.1)——我把这几个分当成”代码量+依赖”的代理,不是真实工程复杂度的完整度量。

小结

  • 根本约束:想测”模型做架构决策的能力”,就得保证它拿到的 ground truth 不泄露实现——可执行文件是”完整编码行为又不泄露结构”的最小物体;换骨架式评测丢架构自由,换联网丢真实性,换源码断言丢跨语言可比性。
  • 崩点:骨架式评测在第一次架构自由时崩(找不到也跑不了重构);联网在第一个稍难任务上崩(20–36% 抄源码);且事后抓作弊不可靠(judge 对 40–57% 任务意见不一)。
  • 共同祖先:行为等价的反向工程线(兄弟是反编译,但求行为不求源码)+ 归纳式程序综合放大到项目级;评测设计是”度量方式即命运”(AI 原理③)的教科书案例。
  • 可带走的动作:下次给 agent 布置”从零做一件事”的任务,先问”它的 ground truth 会不会把答案泄漏给它”;而判断一个 agent 是不是在做”工程”而不是”补全”,看轨迹——它会不会对结果打探、迭代、修订,这比看 pass 率更能说明能力的形状。

下一个问题

这篇的结尾我不打算给”五分钟实验”——因为真正能上手的事是盯一次你自己的 agent 轨迹。下次让 coding agent 从零搭一个小工具,别只看最终通过率,去翻它的命令历史,数两件事:它探测了多少次”输入该长什么样”,又改过几次自己已经写下的文件。 如果两项都接近 0,那它只是在做长代码补全,不是在做软件工程——这不是它”能力弱”,是它根本没进入那个循环。我接下来想试的是:用 ProgramBench 的黑盒思路(金标准可执行文件 + 只按行为判分)给一个我自己的小工具做一次迷你版,看我在”探测规格”这一步会先卡在哪。如果你先做了,欢迎把看到的轨迹形状告诉我。

参考来源

论文

相关方法

  • SWE-bench(Jimenez et al. 2024)——issue-resolution 评测线,ProgramBench 与它互补。
  • Commit0、DevBench、NL2Repo-bench——骨架式”填空”评测,ProgramBench 明确对标的结构性对照。
  • LLM4Decompile(Tan et al.)——反编译还原源码,与 ProgramBench 的”行为等价”是兄弟目标。
  • CodeARC(Wei et al.)——从输入输出例归纳程序,ProgramBench 把它放大到整个项目。

本站相关