Current Limit of AI Automous Coding is a 100,000 Rust Based C Compiler Built in 2 Weeks

Anthropic researcher Nicholas Carlini published a blog post describing how he set 16 instances of the company’s Claude Opus 4.6 AI model loose on a shared codebase with minimal supervision, tasking them with building a C compiler from scratch. Over two weeks and nearly 2,000 Claude Code sessions costing about $20,000 in API fees, the AI model agents reportedly produced a 100,000-line Rust-based compiler capable of building a bootable Linux 6.9 kernel on x86, ARM, and RISC-V architectures. The model hit this wall at around 100,000 lines, which suggests a practical ceiling for autonomous agentic coding, at least with current models.

A year ago, no language model could have produced anything close to a functional multi-architecture compiler, even with this kind of babysitting and an unlimited budget. The methodology of parallel agents coordinating through Git with minimal human supervision is novel, and the engineering tricks Carlini developed to keep the agents productive (context-aware test output, time-boxing, the GCC oracle for parallelization) could potentially represent useful contributions to the wider use of agentic software development tools.

Carlini, a research scientist on Anthropic’s Safeguards team (previously seven years at Google Brain and DeepMind), built a full C compiler using a new “agent teams” feature in Claude Opus 4.6.How the agents workedEach Claude instance ran in its own Docker container. They all cloned the same Git repository, claimed tasks by creating lock files, and pushed finished code back to the shared repo. There was no central orchestrator directing traffic. Instead, every agent independently decided what looked like the most useful problem to tackle next. When merge conflicts occurred, the agents resolved them themselves.

Why a C compiler was the perfect test project

A C compiler is almost ideal for semi-autonomous AI coding.
The language specification is decades old and extremely well-defined.
Comprehensive test suites already exist.

There is a known-good reference compiler (GCC) to compare against.

Most real-world software projects lack these advantages. The hardest part of development is usually deciding what the tests should even be, not just writing code that passes them.Limitations (Carlini was transparent about them)The compiler has no 16-bit x86 backend, so it calls out to GCC for that step.
Its own assembler and linker are still buggy.
Even with all optimizations turned on, it produces less efficient code than GCC with optimizations turned off.
The Rust code is functional but nowhere near what an expert Rust programmer would write.

Carlini wrote: “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.”

The real breakthrough – the agentic workflow

The core innovation wasn’t a single super-prompt or clever trick. It was the system:16 parallel Claude instances working on one shared Git repo
Using lock files to claim tasks without stepping on each other
Automatically resolving merge conflicts
Naturally specializing (one agent focused on parsing, another on optimization and critique, etc.)
Iterating relentlessly through tests and fixes

This is a big step beyond single-model code generation.

What the agents actually built

They created the compiler from scratch in pure Rust (only the standard library, no external crates). It was a brand-new implementation, not a fork or port of any existing codebase.

They implemented
Parsing
Intermediate representation (IR)
Multiple optimization passes
Several backends (x86, ARM, RISC-V)
Assembler
Linker
Debug info generation

All of it emerged through iterative, autonomous reasoning.Human roleHuman involvement was deliberately minimal and high-level

Setting up the agent harness
Writing the initial prompt and specification
Providing test suites
Final validation

No human wrote, debugged, or iteratively refined the code in the traditional sense. The agents ran autonomously in parallel for roughly two weeks across ~2,000 sessions.Results99% pass rate on GCC’s torture test suite
Successfully compiles Linux 6.9 kernel (boots on x86, ARM, and RISC-V, with the minor caveat that it still uses GCC for the 16-bit x86 bootstrap step)
Also compiles real-world projects: PostgreSQL, SQLite, Redis, FFmpeg, QEMU, and even Doom

These aren’t toy benchmarks. They require correct handling of complex C semantics, ABI details, and low-level systems programming edge cases—far beyond simple regurgitation of training data.