Claude Code builds a compiler with sixteen agents
Nicholas Carlini reports that sixteen Claude Code agents built a Rust C compiler that compiled Linux, while exposing coordination failures and remaining toolchain limitations.
anthropic.com
Suggested prompt
Suggested prompt written by Agents In Use, not the source author. Replace bracketed inputs and review tool permissions first.
Build a small compiler prototype in isolated workspaces. Define executable acceptance tests, let agents claim separate failures, merge their changes and report regressions, cost and unfinished compiler components for my review.
Reach people exploring AI agents
See placements →Evidence at a glance
Sourced account- Source author
- Nicholas Carlini
- Original account
- Read the source ↗
- Published
- Source link checked
- Reported result
- Carlini reports a 100,000-line compiler that built Linux 6.9 on three architectures; incomplete toolchain components and inefficient output remained.
- Human involvement
- Carlini specified the design, built and revised the testing environment, assigned specialist roles and documented failures that remained.
A linked account supports attribution. It does not mean we independently reproduced its result.
Report an issue with this case
Open correction emailOpens your email app with the case link included. Nothing is sent automatically.
How the agent did it
- Define compiler targets and prepare compiler tests and project build checks.
- Start sixteen isolated Claude Code sessions with a shared upstream repository.
- Have agents claim tasks, implement changes, merge work and inspect test feedback.
Nicholas Carlini gave sixteen Claude Code agents a shared goal: write a C compiler in Rust that could compile the Linux kernel. A loop restarted agents in separate Docker containers. Each agent chose work, claimed a task through a file in Git, merged other changes and pushed its own results.
Carlini reports nearly 2,000 sessions over two weeks, costing just under $20,000 in API usage. The resulting compiler contained about 100,000 lines and built Linux 6.9 for x86, ARM and RISC-V. The account also reports compiling projects including QEMU, FFmpeg and SQLite, and running Doom.
The difficult part was designing feedback and dividing work. When every agent hit the same kernel bug, extra agents stopped helping. Carlini introduced a harness that mixed GCC-compiled files with files from the new compiler, allowing agents to isolate different failures. He also tightened continuous integration after new features repeatedly broke working behavior.
The result was a research prototype. Its x86 boot path still called GCC for 16-bit code, and the demonstration used an external assembler and linker. Generated code was inefficient, some projects failed, and Carlini repeatedly revised the environment and tests. Autonomous implementation therefore depended on substantial human work defining what counted as progress.
Prompt
Suggested prompt (written by Agents In Use, not the author's)
Source: Blog · Nicholas Carlini
Frequently asked questions
How did the agents avoid choosing the same task?
They claimed tasks through files in a shared Git repository; synchronization forced a second claimant to choose other work.
What unblocked parallel Linux debugging?
A new harness compiled selected files with the experimental compiler and the rest with GCC, helping isolate independent failures.
Was the compiler a complete GCC replacement?
No. It still relied on GCC for the x86 16-bit boot stage, used external assembly and linking in the demo, and could not build every project.
More details
Remaining steps
- Use mixed GCC builds to isolate kernel failures and strengthen regression checks.
About this account
Agents selected tasks, edited and merged code, debugged failures and continued through fresh sessions without a prompt for each change.
Firsthand source opened over HTTP and read on 2026-10-15. Publication date comes from the source page. Outcomes are author-reported and were not independently reproduced. Suggested prompt written by Agents In Use. Research prototype; author-designed tests and repeated interventions; compilation claims not independently reproduced.
Credit: Nicholas Carlini
Source published
Added to Agents In Use
Source checked
Tools and topics
Claude Code · Docker · Git · Rust · GCC
Compiler development · Parallel agents · Regression checks
Editorial completeness: 100/100. Measures documented fields, not agent performance or verified outcomes.