# carlini-anthropic-building-c-compiler-parallel-claudes-2026-02-05

## Veille

Compilatore C in Rust costruito da 16 agenti Claude autonomi in parallelo - Anthropic

## Titre Article

Building a C Compiler with a Team of Parallel Claudes

## Date

2026-02-05

## URL

https://www.anthropic.com/engineering/building-c-compiler

## Keywords

compilatore C, Rust, agenti paralleli, Claude Opus 4.6, autonomia degli agenti IA, Claude Code, agentic coding, Linux 6.9, x86, ARM, RISC-V, 100.000 righe, 20.000 dollari, Docker, sincronizzazione degli agenti, test automatizzati, GCC, specializzazione degli agenti, sicurezza degli agenti autonomi

## Authors

Nicholas Carlini (chercheur équipe Safeguards, Anthropic)

## Ton

**Profilo**: articolo tecnico di ingegneria, registro narrativo-analitico, livello tecnico molto avanzato

**Descrizione**: post del blog di ingegneria Anthropic che combina la narrazione di un esperimento con lezioni tecniche. Il tono è quello di un ricercatore di sicurezza che condivide, con entusiasmo e onestà, un progetto personale che spinge i limiti del modello. La scrittura alterna descrizioni tecniche precise (script bash, architettura Docker, algoritmi di sincronizzazione) a riflessioni più ampie sulle implicazioni. L'autore riconosce apertamente i limiti e i rischi di sicurezza, portando una prospettiva sfumata grazie a un background in penetration testing. Il pubblico target è composto da ingegneri e ricercatori IA interessati ai sistemi multi-agente autonomi.

## Pense-betes

- **Risultato principale**: compilatore C in Rust di 100.000 righe, costruito da 16 agenti Claude Opus 4.6 in parallelo, ~2.000 sessioni Claude Code, costo ~20.000 dollari
- **Il compilatore compila Linux 6.9** su x86, ARM e RISC-V, oltre a QEMU, FFmpeg, SQLite, PostgreSQL, Redis e Doom
- **Architettura di agenti paralleli**:
- Semplice loop bash che rilancia Claude in modalità `--dangerously-skip-permissions`
- Container Docker isolati, repository montati in `/upstream`
- Sincronizzazione tramite file di lock in `current_tasks/` + Git
- Nessuna comunicazione inter-agente né orchestrazione esplicita — selezione autonoma dei compiti
- **Specializzazione dei ruoli**: deduplicazione del codice, ottimizzazione delle prestazioni, efficienza del codice generato, revisione del design Rust, documentazione
- **Lezioni chiave per gli agenti autonomi**: 1. **Test di altissima qualità**: gli agenti risolvono esattamente ciò che viene loro assegnato, quindi la precisione dei test è cruciale 2. **Pensare dal punto di vista di Claude**: ogni agente entra in un container vuoto → sono necessari README esaustivi; output di test minimo; flag `--fast` per campionamento casuale (1-10%) 3. **Abilitare il parallelismo**: semplice quando molti test indipendenti falliscono, difficile per un compito monolitico (ad es. la compilazione del kernel Linux). Soluzione: GCC come "oracolo di riferimento" + compilazione parziale casuale 4. **Ruoli multipli**: la specializzazione diventa possibile una volta stabilito il parallelismo
- **Progressione dei modelli**: Opus 4 = compilatore appena funzionante, Opus 4.5 = primo compilatore a superare le suite di test, Opus 4.6 = compila Linux
- **Consumo**: 2 miliardi di token in input, 140 milioni di token in output, ~20.000 dollari — una frazione del costo dello sviluppo umano
- **Limiti onestamente riconosciuti**: nessun supporto x86 a 16 bit (ricade su GCC), assembler/linker incompleti, non universalmente compatibile, codice generato meno performante di GCC -O0, qualità del codice Rust discreta ma non a livello esperto
- **Sicurezza**: l'autore (background in pentest) sottolinea che il superamento dei test non garantisce la correttezza; il dispiegamento di software autonomo non verificato è un rischio reale
- **Citazione memorabile**: "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."
- **Codice sorgente**: disponibile su GitHub (anthropics/claudes-c-compiler)

## RésuméDe400mots

Nicholas Carlini, ricercatore nel team Safeguards di Anthropic, ha condotto un esperimento ambizioso: far costruire un compilatore C in Rust interamente da agenti Claude Opus 4.6 che lavorano in parallelo, senza alcun intervento umano diretto sul codice.

**Architettura multi-agente**: 16 istanze Claude hanno lavorato simultaneamente in container Docker isolati, condividendo un repository Git upstream. Ogni agente seleziona autonomamente il proprio compito successivo tramite un sistema di file-locking. La sincronizzazione si basa su Git: un agente si assegna un compito, ci lavora, effettua il push delle modifiche, quindi passa al successivo. Non è richiesta alcuna comunicazione esplicita tra agenti.

**Risultati notevoli**: in circa 2.000 sessioni Claude Code e 20.000 dollari di costi API (2 miliardi di token in input, 140 milioni di token in output), il compilatore risultante, di 100.000 righe, compila con successo Linux 6.9 su tre architetture (x86, ARM, RISC-V), oltre a progetti di rilievo come QEMU, FFmpeg, SQLite, PostgreSQL, Redis e persino Doom, con un tasso di successo del 99% sulle suite di test per compilatori, inclusa la GCC torture suite.

**Lezioni di progettazione**: l'autore condivide quattro insegnamenti chiave. Primo, la qualità dei test è cruciale perché gli agenti risolvono esattamente ciò che viene specificato. Secondo, occorre pensare dal punto di vista di Claude: ogni agente entra in un ambiente vuoto senza contesto, il che richiede una documentazione esaustiva e un output minimo per preservare la finestra di contesto. Terzo, abilitare il parallelismo è essenziale: semplice quando molti test indipendenti falliscono, ma la compilazione del kernel Linux si è rivelata problematica perché tutti gli agenti correggevano gli stessi bug. La soluzione: usare GCC come "oracolo di riferimento" per distribuire in modo casuale i file da compilare. Quarto, specializzare gli agenti per ruolo (deduplicazione, ottimizzazione, revisione del design, documentazione) massimizza l'efficienza.

**Progressione dei modelli**: l'articolo funge anche da benchmark di capacità. Opus 4 produceva a malapena un compilatore funzionante, Opus 4.5 ha permesso al primo compilatore di superare le suite di test, e Opus 4.6 spinge oltre i limiti compilando veri progetti su larga scala.

**Preoccupazioni di sicurezza**: l'autore, forte di un background in penetration testing, osserva che il superamento dei test non garantisce la correttezza del software. Il dispiegamento autonomo di codice non verificato da esseri umani rappresenta un rischio reale che richiede nuove strategie di sicurezza. Il codice sorgente è disponibile su GitHub (anthropics/claudes-c-compiler).

## GrapheDeConnaissance

- Nicholas Carlini —utilise→ agents parallèles (METHODOLOGIE, 0.99)
- Nicholas Carlini —travaille_chez→ Anthropic (ORGANISATION, 0.99)
- Nicholas Carlini —a_créé→ compilateur C en Rust (TECHNOLOGIE, 0.99)
- Claude Opus 4.6 —a_créé→ compilateur C en Rust (TECHNOLOGIE, 0.99)
- compilateur C en Rust —s_applique_à→ Linux 6.9 (TECHNOLOGIE, 0.98)
- compilateur C en Rust —mesure→ 99% de réussite sur suites de tests (MESURE, 0.97)
- agents parallèles —utilise→ Docker (TECHNOLOGIE, 0.98)
- agents parallèles —utilise→ synchronisation par fichiers verrou (METHODOLOGIE, 0.97)
- agents parallèles —utilise→ GCC (TECHNOLOGIE, 0.95)
- spécialisation par rôle —améliore→ agents parallèles (METHODOLOGIE, 0.9)
- sécurité agents autonomes —est_basé_sur→ vérification humaine (CONCEPT, 0.92)
- Nicholas Carlini —affirme_que→ la qualité des tests est critique pour les agents autonomes (AFFIRMATION, 0.97)
- Claude Opus 4.6 —surpasse→ Claude Opus 4.5 (TECHNOLOGIE, 0.96)

---
Canonical: https://www.thekb.eu/it/fiches/carlini-anthropic-building-c-compiler-parallel-claudes-2026-02-05/