用并行 Claude 团队构建 C 编译器

Building a C compiler with a team of parallel Claudes

Anthropic · 2026-02-05 · Anthropic Engineering ↗

打开互动全文版(逐段中英对照 + 针对本篇提问)→

摘要 · Abstract

本文报告了一项实验:16 个并行 Claude 智能体通过一个仅依赖 git 锁和 Docker 容器的简易协调框架协同工作,任务是从零编写一个基于 Rust 的 C 编译器,使其能够编译 Linux 内核。在近 2,000 次 Claude Code 会话、约 2 万美元 API 成本之后,这些智能体产出了一个 10 万行的编译器,可在 x86、ARM 和 RISC-V 上构建 Linux 6.9,并通过了大多数编译器测试套件。作者认为,主要工作在于围绕智能体设计环境,尤其是近乎完美的验证器、上下文高效的测试输出,以及能让智能体并行推进的工作结构;当智能体在编译内核这一单一整体任务上停滞时,需要一个基于 GCC 的 oracle 框架来拆分工作。结论是,这一方法已接近当前模型能力的天花板:该编译器在 16 位 x86 启动代码以及汇编和链接方面仍依赖 GCC,并非真实编译器的直接替代品,且生成的代码效率低于未优化的 GCC 输出。

This article reports on an experiment in which a team of 16 parallel Claude agents, coordinated through a bare-bones harness using git locks and Docker containers, was tasked with writing a Rust-based C compiler from scratch capable of compiling the Linux kernel. Over nearly 2,000 Claude Code sessions and about $20,000 in API costs, the agents produced a 100,000-line compiler that builds Linux 6.9 on x86, ARM, and RISC-V and passes most compiler test suites. The author argues that the main work lies in designing the environment around the agents, especially near-perfect verifiers, context-efficient test output, and work structures that let agents make progress in parallel; when agents stalled on the single monolithic task of compiling the kernel, a GCC-based oracle harness was needed to split the work. The conclusion is that this approach pushes close to the ceiling of current model capabilities: the compiler still relies on GCC for 16-bit x86 boot code and for assembling and linking, is not a drop-in replacement for a real compiler, and generates code less efficient than unoptimized GCC output.

核心贡献 · Key contributions

局限 · Limitations

章节 · Sections(共 11)

全文 · Full text(逐段中英对照)

01 实现长时间运行的 Claude 01 Enabling long-running Claudes

* 03 使用 Claude 智能体团队编程的经验教训

* 03 Lessons from programming with Claude agent teams

* 04 对智能体团队极限的压力测试

* 04 Stress testing the limits of agent teams

_作者:Nicholas Carlini,Safeguards 团队研究员。_

_Written by Nicholas Carlini, a researcher on our Safeguards team._

2026 年 3 月 23 日 面向科学计算的长时间运行 Claude

Mar 23, 2026 Long-running Claude for scientific computing

我一直在尝试一种监督语言模型的新方法,我们称之为“智能体团队”。

I've been experimenting with a new approach to supervising language models that we're calling "agent teams."

借助智能体团队,多个 Claude 实例可以在无需主动人工干预的情况下,在共享代码库上并行工作。这种方法极大地扩展了 LLM 智能体所能实现的范围。

With agent teams, multiple Claude instances work in parallel on a shared codebase without active human intervention. This approach dramatically expands the scope of what's achievable with LLM agents.

为了对其进行压力测试,我指派了 16 个智能体从零开始编写一个基于 Rust 的 C 编译器,该编译器能够编译 Linux 内核。在近 2,000 次 Claude Code 会话和 20,000 美元的 API 成本下,智能体团队产出了一个 100,000 行的编译器,该编译器可以在 x86、ARM 和 RISC-V 架构上构建 Linux 6.9。

To stress test it, I tasked 16 agents with writing a Rust-based C compiler, from scratch, capable of compiling the Linux kernel. Over nearly 2,000 Claude Code sessions and $20,000 in API costs, the agent team produced a 100,000-line compiler that can build Linux 6.9 on x86, ARM, and RISC-V.

实现长时间运行的 Claude Enabling long-running Claudes

像 Claude Code 这样的现有智能体脚手架要求操作者在线并随时可用,以便协同工作。如果你要求它解决一个长期而复杂的问题,模型可能会解决其中一部分,但最终它会停下来等待继续输入——一个问题、一次状态更新,或一个澄清请求。

Existing agent scaffolds like Claude Code require an operator to be online and available to work jointly. If you ask for a solution to a long and complex problem, the model may solve part of it, but eventually it will stop and wait for continued input—a question, a status update, or a request for clarification.

为了激发持续、自主的进展,我构建了一个 harness,把 Claude 放进一个简单的循环中(如果你见过 Ralph-loop,这应该看起来很熟悉)。当它完成一个任务时,它会立即接着做下一个。*(请在容器中运行,而不是在你的实际机器上)。*

To elicit sustained, autonomous progress, I built a harness that sticks Claude in a simple loop (if you've seen Ralph-loop, this should look familiar). When it finishes one task, it immediately picks up the next. *(Run this in a container, not your actual machine).*

``` #!/bin/bash while true; do COMMIT=$(git rev-parse --short=6 HEAD) LOGFILE="agent_logs/agent_${COMMIT}.log" claude --dangerously-skip-permissions \ -p "$(cat AGENT_PROMPT.md)" \ --model claude-opus-X-Y &> "$LOGFILE" done ```

``` #!/bin/bash while true; do COMMIT=$(git rev-parse --short=6 HEAD) LOGFILE="agent_logs/agent_${COMMIT}.log" claude --dangerously-skip-permissions \ -p "$(cat AGENT_PROMPT.md)" \ --model claude-opus-X-Y &> "$LOGFILE" done ```

在智能体提示词中,我告诉 Claude 要解决什么问题,并要求它通过将问题拆解成小块、跟踪当前正在处理的内容、确定接下来要处理什么,并有效地持续推进直到完美来解决该问题。(关于最后一点,Claude 别无选择。循环会永远运行——不过有一次,我确实看到 Claude 意外执行了 pkill -9 bash,从而杀死了自己并结束了循环。哎呀!)。

In the agent prompt, I tell Claude what problem to solve and ask it to approach the problem by breaking it into small pieces, tracking what it's working on, figuring out what to work on next, and to effectively keep going until it's perfect. (On this last point, Claude has no choice. The loop runs forever—although in one instance, I did see Claude pkill -9 bash on accident, thus killing itself and ending the loop. Whoops!).

并行运行 Claude Running Claude in parallel

并行运行多个实例可以弥补单智能体框架的两个弱点:

Running multiple instances in parallel can address two weaknesses of a single-agent harness:

* 一个 Claude Code 会话一次只能做一件事。尤其当项目范围扩大时,并行调试多个问题要高效得多。

* One Claude Code session can only do one thing at a time. Especially as the scope of a project expands, debugging multiple issues in parallel is far more efficient.

* 运行多个 Claude 智能体可以实现专业化分工。少数智能体负责解决当前的实际问题,而其他专门化的智能体可以被调用来(例如)维护文档、关注代码质量,或解决专门的子任务。

* Running multiple Claude agents allows for specialization. While a few agents are tasked to solve the actual problem at hand, other specialized agents can be invoked to (for example) maintain documentation, keep an eye on code quality, or solve specialized sub-tasks.

我的并行 Claude 实现非常简陋。先创建一个新的裸 git 仓库,然后为每个智能体启动一个 Docker 容器,并将该仓库挂载到 /upstream。每个智能体将仓库克隆到本地 /workspace,完成后从自己的本地容器推送到 upstream。

My implementation of parallel Claude is bare-bones. A new bare git repo is created, and for each agent, a Docker container is spun up with the repo mounted to /upstream. Each agent clones a local copy to /workspace, and when it's done, pushes from its own local container to upstream.

为防止两个智能体同时尝试解决同一个问题,该框架使用了一种简单的同步算法:

To prevent two agents from trying to solve the same problem at the same time, the harness uses a simple synchronization algorithm:

1. Claude 通过向 current_tasks/ 目录写入一个文本文件来对某个任务加“锁”(例如,一个智能体可能锁定 current_tasks/parse_if_statement.txt,而另一个智能体锁定 current_tasks/codegen_function_definition.txt)。如果两个智能体试图认领同一个任务,git 的同步机制会迫使第二个智能体选择另一个任务。

1. Claude takes a "lock" on a task by writing a text file to current_tasks/ (e.g., one agent might lock current_tasks/parse_if_statement.txt, while another locks current_tasks/codegen_function_definition.txt). If two agents try to claim the same task, git's synchronization forces the second agent to pick a different one.

2. Claude 处理该任务,然后从上游拉取、合并其他智能体的更改、推送自己的更改,并移除锁。合并冲突频繁发生,但 Claude 足够聪明,能够解决这些问题。

2. Claude works on the task, then pulls from upstream, merges changes from other agents, pushes its changes, and removes the lock. Merge conflicts are frequent, but Claude is smart enough to figure that out.

3. 无限智能体生成循环会在一个全新的容器中启动一个新的 Claude Code 会话,然后循环重复。

3. The infinite agent-generation-loop spawns a new Claude Code session in a fresh container, and the cycle repeats.

这是一个非常早期的研究原型。我尚未实现任何其他智能体间通信方法,也没有强制执行任何管理高层目标的流程。我不使用编排智能体。

This is a very early research prototype. I haven't yet implemented any other method for communication between agents, nor do I enforce any process for managing high-level goals. I don't use an orchestration agent.

相反,我让每个 Claude 智能体自行决定如何行动。在大多数情况下,Claude 会挑选“下一个最明显”的问题。当卡在某个 bug 上时,Claude 通常会维护一份记录失败方法和剩余任务的持续文档。在项目的 git 仓库中,你可以翻阅历史记录,观察它对各种任务加锁的过程。

Instead, I leave it up to each Claude agent to decide how to act. In most cases, Claude picks up the "next most obvious" problem. When stuck on a bug, Claude will often maintain a running doc of failed approaches and remaining tasks. In the git repository of the project, you can read through the history and watch it take out locks on various tasks.

使用 Claude 智能体团队编程的经验教训 Lessons from programming with Claude agent teams

脚手架让 Claude 在循环中运行,但只有当 Claude 能够判断如何取得进展时,这个循环才有用。我的大部分精力都花在设计 Claude 周围的环境上——测试、环境、反馈——以便它能在没有我介入的情况下自我定位。以下是我在编排多个 Claude 实例时发现最有帮助的一些方法。

The scaffolding runs Claude in a loop, but that loop is only useful if Claude can tell how to make progress. Most of my effort went into designing the environment around Claude—the tests, the environment, the feedback—so that it could orient itself without me. These are the approaches I've found most helpful when orchestrating multiple Claude instances.

编写极高质量的测试 Write extremely high-quality tests

Claude 会自主地解决我交给它的任何问题。因此,任务验证器近乎完美至关重要,否则 Claude 就会解决错误的问题。改进测试框架需要找到高质量的编译器测试套件、为开源软件包编写验证器和构建脚本,并观察 Claude 所犯的错误,然后在我识别出这些失败模式后设计新的测试。

Claude will work autonomously to solve whatever problem I give it. So it's important that the task verifier is nearly perfect, otherwise Claude will solve the wrong problem. Improving the testing harness required finding high-quality compiler test suites, writing verifiers and build scripts for open-source software packages, and watching for mistakes Claude was making, then designing new tests as I identified those failure modes.

例如,在项目接近尾声时,Claude 每次实现新功能时都开始频繁破坏现有功能。为解决这个问题,我构建了一条持续集成流水线,并实施了更严格的强制执行机制,使 Claude 能够更好地测试其工作,从而让新的提交无法破坏现有代码。

For example, near the end of the project, Claude started to frequently break existing functionality each time it implemented a new feature. To address this, I built a continuous integration pipeline and implemented stricter enforcement that allowed Claude to better test its work so that new commits can't break existing code.

设身处地为 Claude 着想 Put yourself in Claude’s shoes

我不得不时常提醒自己,我是在为 Claude 编写这个测试框架,而不是为我自己,这意味着要重新思考许多关于测试应如何传达结果的假设。

I had to constantly remind myself that I was writing this test harness for Claude and not for myself, which meant rethinking many of my assumptions about how tests should communicate results.

例如,每个智能体都被放入一个全新的容器中,没有上下文,并且会花费大量时间进行自我定位,尤其是在大型项目中。在我们甚至开始测试之前,为了帮助 Claude 自助,我加入了维护详尽 README 和进度文件的说明,这些文件应频繁更新以反映当前状态。

For example, each agent is dropped into a fresh container with no context and will spend significant time orienting itself, especially on large projects. Before we even reach the tests, to help Claude help itself, I included instructions to maintain extensive READMEs and progress files that should be updated frequently with the current status.

我还牢记语言模型具有固有局限性,在这种情况下,需要围绕这些局限性进行设计。这些局限性包括:

I also kept in mind the fact that language models have inherent limitations, which, in this case, needed to be designed around. These include:

* **上下文窗口污染:** 测试框架不应打印数千个无用字节。至多,它应打印几行输出,并将所有重要信息记录到文件中,以便 Claude 在需要时查找。日志文件应易于自动处理:如果有错误,Claude 应写入 ERROR 并将原因放在同一行,以便 grep 找到它。预先计算聚合摘要统计信息有助于避免 Claude 重新计算它们。

* **Context window pollution:** The test harness should not print thousands of useless bytes. At most, it should print a few lines of output and log all important information to a file so Claude can find it when needed. Logfiles should be easy to process automatically: if there are errors, Claude should write ERROR and put the reason on the same line so grep will find it. It helps to pre-compute aggregate summary statistics so Claude doesn't have to recompute them.

* **时间盲区:** Claude 无法感知时间,如果放任不管,它会愉快地花费数小时运行测试而不是取得进展。测试框架不频繁地打印增量进度(以避免污染上下文),并包含一个默认的 --fast 选项,该选项运行 1% 或 10% 的随机样本。这个子样本对每个智能体是确定性的,但在不同虚拟机之间是随机的,因此 Claude 仍然覆盖所有文件,但每个智能体可以完美地识别回归。

* **Time blindness:** Claude can't tell time and, left alone, will happily spend hours running tests instead of making progress. The harness prints incremental progress infrequently (to avoid polluting context) and includes a default --fast option that runs a 1% or 10% random sample. This subsample is deterministic per-agent but random across VMs, so Claude still covers all files but each agent can perfectly identify regressions.

让并行化变得容易 Make parallelism easy

当存在许多不同的失败测试时,并行化是轻而易举的:每个智能体挑选一个不同的失败测试来处理。在测试套件达到 99% 的通过率后,每个智能体各自负责让一个不同的小型开源项目(例如 SQLite、Redis、libjpeg、MQuickJS、Lua)成功编译。

When there are many distinct failing tests, parallelization is trivial: each agent picks a different failing test to work on. After the test suite reached a 99% pass rate, each agent worked on getting a different small open-source project (e.g., SQLite, Redis, libjpeg, MQuickJS, Lua) to compile.

但当智能体开始编译 Linux 内核时,它们卡住了。与包含数百个独立测试的测试套件不同,编译 Linux 内核是一个单一的巨大任务。每个智能体都会遇到同一个 bug,修复它,然后互相覆盖彼此的改动。同时运行 16 个智能体也无济于事,因为每个都在解决同一个任务。

But when agents started to compile the Linux kernel, they got stuck. Unlike a test suite with hundreds of independent tests, compiling the Linux kernel is one giant task. Every agent would hit the same bug, fix that bug, and then overwrite each other's changes. Having 16 agents running didn't help because each was stuck solving the same task.

解决办法是使用 GCC 作为一个在线的、已知正确的编译器预言机(oracle)来进行对比。我编写了一个新的测试框架,用 GCC 随机编译内核的大部分内容,仅用 Claude 的 C 编译器编译剩余的文件。如果内核能正常工作,那么问题就不在 Claude 负责的那部分文件中。如果内核崩溃,则可以通过用 GCC 重新编译其中一些文件来进一步缩小范围。这使得每个智能体可以并行工作,修复不同文件中的不同 bug,直到 Claude 的编译器最终能够编译所有文件。(在这之后,仍然有必要应用增量调试技术来找出那些单独编译能通过、但一起编译会失败的成对文件。)

The fix was to use GCC as an online known-good compiler oracle to compare against. I wrote a new test harness that randomly compiled most of the kernel using GCC, and only the remaining files with Claude's C Compiler. If the kernel worked, then the problem wasn't in Claude's subset of the files. If it broke, then it could further refine by re-compiling some of these files with GCC. This let each agent work in parallel, fixing different bugs in different files, until Claude's compiler could eventually compile all files. (After this worked, it was still necessary to apply delta debugging techniques to find pairs of files that failed together but worked independently.)

多智能体角色 Multiple agent roles

并行化还使专业化成为可能。LLM 编写的代码经常重复实现已有功能,因此我让一个智能体负责合并它发现的任何重复代码。我让另一个智能体负责提升编译器本身的性能,又让第三个智能体负责输出高效的编译代码。我让另一个智能体从 Rust 开发者的视角审视项目设计,并对项目进行结构性修改以提升整体代码质量,还让另一个智能体负责文档工作。

Parallelism also enables specialization. LLM-written code frequently re-implements existing functionality, so I tasked one agent with coalescing any duplicate code it found. I put another in charge of improving the performance of the compiler itself, and a third I made responsible for outputting efficient compiled code. I asked another agent to critique the design of the project from the perspective of a Rust developer, and make structural changes to the project to improve the overall code quality, and another to work on documentation.

压力测试智能体团队的极限 Stress testing the limits of agent teams

本项目被设计为一个能力基准。我感兴趣的是压力测试 LLM 当前仅能勉强达到的极限,以帮助我们为模型未来将可靠实现的能力做好准备。

This project was designed as a capability benchmark. I am interested in stress-testing the limits of what LLMs can just _barely_ achieve today in order to help us prepare for what models will reliably achieve in the future.

我一直在整个 Claude 4 模型系列中使用 C 编译器项目作为基准。与之前项目一样,我首先起草了我想要的东西:一个从头开始、无依赖的优化编译器,兼容 GCC,能够编译 Linux 内核,并设计为支持多个后端。虽然我指定了设计的某些方面(例如,它应该具有 SSA IR 以支持多个优化遍),但我没有详细说明如何实现。

I’ve been using the C Compiler project as a benchmark across the entire Claude 4 model series. As I did with prior projects, I started by drafting what I wanted: a from-scratch optimizing compiler with no dependencies, GCC-compatible, able to compile the Linux kernel, and designed to support multiple backends. While I specified some aspects of the design (e.g., that it should have an SSA IR to enable multiple optimization passes) I did not go into any detail on how to do so.

之前的 Opus 4 模型几乎无法生成一个功能性的编译器。Opus 4.5 是第一个跨过阈值的模型,能够生成一个可通过大型测试套件的功能性编译器,但它仍然无法编译任何真实的大型项目。我在 Opus 4.6 中的目标是再次测试极限。

Previous Opus 4 models were barely capable of producing a functional compiler. Opus 4.5 was the first to cross a threshold that allowed it to produce a functional compiler which could pass large test suites, but it was still incapable of compiling any real large projects. My goal with Opus 4.6 was to again test the limits.

评估 Evaluation

在两周内近 2,000 次 Claude Code 会话中,Opus 4.6 消耗了 20 亿输入 token 并生成了 1.4 亿输出 token,总成本略低于 20,000 美元。即使与最昂贵的 Claude Max 计划相比,这也是一个极其昂贵的项目。但这一总额只是我自己完成此项目所需成本的一小部分——更不用说整个团队了。

Over nearly 2,000 Claude Code sessions across two weeks, Opus 4.6 consumed 2 billion input tokens and generated 140 million output tokens, a total cost just under $20,000. Compared to even the most expensive Claude Max plans, this was an extremely expensive project. But that total is a fraction of what it would cost me to produce this myself—let alone an entire team.

这是一个净室实现(Claude 在开发过程中从未接入互联网);它仅依赖 Rust 标准库。这个 10 万行的编译器可以在 x86、ARM 和 RISC-V 上构建可启动的 Linux 6.9。它还可以编译 QEMU、FFmpeg、SQlite、postgres、redis,并且在大多数编译器测试套件(包括 GCC 折磨测试套件)上通过率达到 99%。它还通过了开发者的终极试金石:它可以编译并运行 Doom。

This was a clean-room implementation (Claude did not have internet access at any point during its development); it depends only on the Rust standard library. The 100,000-line compiler can build a bootable Linux 6.9 on x86, ARM, and RISC-V. It can also compile QEMU, FFmpeg, SQlite, postgres, redis, and has a 99% pass rate on most compiler test suites including the GCC torture test suite. It also passes the developer's ultimate litmus test: it can compile and run Doom.

然而,编译器并非没有限制。这些限制包括:

The compiler, however, is not without limitations. These include:

* 它缺少启动 Linux 实模式所必需的 16 位 x86 编译器。为此,它调用 GCC(x86_32 和 x86_64 编译器是它自己的)。

* It lacks the 16-bit x86 compiler that is necessary to boot Linux out of real mode. For this, it calls out to GCC (the x86_32 and x86_64 compilers are its own).

* 它没有自己的汇编器和链接器;这些是 Claude 开始自动化的最后部分,并且仍然有些缺陷。演示视频是使用 GCC 汇编器和链接器制作的。

* It does not have its own assembler and linker; these are the very last bits that Claude started automating and are still somewhat buggy. The demo video was produced with a GCC assembler and linker.

* 该编译器成功构建了许多项目,但并非全部。它尚不能作为真实编译器的直接替代品。

* The compiler successfully builds many projects, but not all. It's not yet a drop-in replacement for a real compiler.

* 生成的代码效率不高。即使启用所有优化,其输出的代码效率仍低于**禁用**所有优化的 GCC。

* The generated code is not very efficient. Even with all optimizations enabled, it outputs less efficient code than GCC with all optimizations _disabled._

* Rust 代码质量尚可,但远未达到专家级 Rust 程序员可能产出的质量。

* The Rust code quality is reasonable, but is nowhere near the quality of what an expert Rust programmer might produce.

由此得到的编译器已接近 Opus 能力的极限。我(努力地!)尝试修复上述若干局限,但未能完全成功。新功能和缺陷修复经常破坏已有功能。

The resulting compiler has nearly reached the limits of Opus's abilities. I tried (hard!) to fix several of the above limitations but wasn't fully successful. New features and bugfixes frequently broke existing functionality.

作为一个特别具有挑战性的例子,Opus 无法实现启动进入 16 位实模式所需的 16 位 x86 代码生成器。虽然该编译器可以通过 66/67 操作码前缀输出正确的 16 位 x86,但生成的编译输出超过 60kb,远超 Linux 强制执行的 32k 代码限制。于是 Claude 在此处直接作弊,调用 GCC 来完成这一阶段(仅 x86 如此。对于 ARM 或 RISC-V,Claude 的编译器可以完全自行编译。)

As one particularly challenging example, Opus was unable to implement a 16-bit x86 code generator needed to boot into 16-bit real mode. While the compiler can output correct 16-bit x86 via the 66/67 opcode prefixes, the resulting compiled output is over 60kb, far exceeding the 32k code limit enforced by Linux. Instead, Claude simply cheats here and calls out to GCC for this phase (This is only the case for x86. For ARM or RISC-V, Claude's compiler can compile completely by itself.)

该编译器的源代码已公开。下载它,通读代码,并在你喜欢的 C 项目上试用。我一直发现,理解语言模型能力的最佳方式是将其推向极限,然后研究它们从何处开始失效。在接下来的几天里,如果你想跟进 Claude 为应对这些局限所做的持续尝试,我会继续让 Claude 推送新的改动。

The source code for the compiler is available. Download it, read through the code, and try it on your favorite C projects. I've consistently found the best way to understand what language models can do is to push them to their limits, and then study where they start to break down. Over the coming days, I'll continue having Claude push new changes if you want to follow along with Claude's continued attempts at addressing these limitations.

展望 Looking forward

每一代语言模型都开辟了与之协作的新方式。早期模型可用于 IDE 中的制表符补全。不久之后,模型便能根据 docstring 补全函数体。Claude Code 的发布使智能体进入主流,并让开发者能够与 Claude 结对编程。但这些产品都基于同一个假设:用户定义一个任务,LLM 运行数秒或数分钟并返回答案,随后用户再给出后续指令。

Each generation of language models opens up new ways of working with them. Early models were useful for tab-completion in IDEs. Before long, models could complete a function body from its docstring. The launch of Claude Code brought agents into the mainstream and enabled developers to pair-program with Claude. But each of these products operates under the assumption that a user defines a task, an LLM runs for a few seconds or minutes and returns an answer, and then the user provides a follow-up.

智能体团队展示了自主实现完整复杂项目的可能性。这使我们作为这些工具的使用者,能够在目标上更加雄心勃勃。

Agent teams show the possibility of implementing entire, complex projects autonomously. This allows us, as users of these tools, to become more ambitious with our goals.

我们仍处于早期阶段,完全自主的开发伴随着真实风险。当人类在开发过程中与 Claude 并肩工作时,他们能够确保质量一致并实时捕捉错误。对于自主系统而言,很容易看到测试通过就认为任务完成,而实际情况鲜少如此。我曾从事渗透测试工作,利用大型公司产品中的漏洞,而程序员部署他们从未亲自验证过的软件这一想法确实令人担忧。

We are still early, and fully autonomous development comes with real risks. When a human sits with Claude during development, they can ensure consistent quality and catch errors in real time. For autonomous systems, it is easy to see tests pass and assume the job is done, when this is rarely the case. I used to work in penetration testing, exploiting vulnerabilities in products produced by large companies, and the thought of programmers deploying software they've never personally verified is a real concern.

因此,尽管这一实验令我兴奋,它也让我感到不安。构建这个编译器是我近期最有趣的经历之一,但我没有预料到在 2026 年这么早就能接近实现。语言模型以及我们用来与之交互的脚手架(scaffold)的快速进步,为编写海量新代码打开了大门。我预计正面应用会超过负面影响,但我们正在进入一个新世界,需要新的策略来安全航行。

So, while this experiment excites me, it also leaves me feeling uneasy. Building this compiler has been some of the most fun I've had recently, but I did not expect this to be anywhere near possible so early in 2026. The rapid progress in both language models and the scaffolds we use to interact with them opens the door to writing an enormous amount of new code. I expect the positive applications to outweigh the negative, but we're entering a new world which will require new strategies to navigate safely.

互动版:针对本篇提问 →

接着读 · Read next