Come Claude Code ha riscritto Bun in Rust: una guida in sei passi per la migrazione su larga scala

Introduzione

Un tempo, la migrazione di un linguaggio di programmazione su larga scala era il tipo di progetto che i team di ingegneria rimandavano per anni. Costosa, dirompente e rischiosa. Un'azienda poteva passare diversi trimestri a mantenere due versioni contemporaneamente, per poi ottenere un sostituto dal comportamento incoerente con l'originale.

Claude Code sta cambiando questa situazione.

Anthropic ha recentemente pubblicato il suo processo di migrazione del codice su larga scala tramite agenti AI. Il caso più eclatante è quello di Jarred Sumner, creatore di Bun, che ha migrato il core di Bun da Zig a Rust. In meno di due settimane, il flusso di lavoro di Claude Code ha generato oltre un milione di righe di codice, e la suite di test esistente di Bun ha superato i test di integrazione continua prima del merge.

Questo progetto non è stato completato semplicemente chiedendo al modello di "riscrivere Bun in Rust" e aspettando la risposta perfetta. Si è basato su un sistema accuratamente progettato, che includeva manuali, mappe delle dipendenze, code meccaniche, revisori antagonisti, compilatori, test di fumo e verifiche di coerenza comportamentale.

La lezione fondamentale è chiara: per migrazioni di queste dimensioni, gli sviluppatori non dovrebbero passare la maggior parte del tempo a correggere singoli file. Dovrebbero migliorare il processo di generazione, revisione e verifica di tali file.

Il creatore di Bun ha riscritto oltre un milione di righe di codice usando l'AI

Jarred Sumner ha inizialmente costruito Bun con Zig. Questo linguaggio permetteva a uno sviluppatore indipendente di ottenere sia il controllo di basso livello e le prestazioni simili al C, senza dover affrontare tutta la complessità dell'ecosistema di un linguaggio di sistema più grande.

Questa scelta ha aiutato Bun a crescere rapidamente nelle fasi iniziali. Sumner ha dichiarato di aver scritto la prima versione in circa un anno, in un piccolo appartamento di Oakland, quando ancora non esistevano modelli di codifica moderni.

Nel 2026, Bun è diventato un runtime, package manager, test runner e bundler per JavaScript e TypeScript ampiamente utilizzato. I suoi strumenti da riga di comando ricevono decine di milioni di download al mese, e prodotti come Claude Code dipendono fortemente da Bun.

La crescita ha anche reso impossibile ignorare i vecchi compromessi ingegneristici.

Bun combina un motore JavaScript con garbage collection con memoria nativa gestita manualmente. In Zig, gli sviluppatori devono ragionare esplicitamente su allocazioni, deallocazioni, percorsi di errore e cicli di vita degli oggetti. Il team di Bun ha investito molto in sanitizer, fuzzing, build di sicurezza e test di perdita di memoria, ma continuavano a verificarsi errori di use-after-free, double free, memory leak ed errori di ciclo di vita.

Rust offre una base diversa. Il suo sistema di ownership, il borrow checker e la pulizia automatica possono trasformare molti problemi di memoria a runtime in errori di compilazione.

Storicamente, questo vantaggio non era sufficiente a giustificare una riscrittura completa. Bun conteneva centinaia di migliaia di righe di codice Zig, oltre a numerose integrazioni native. Una riscrittura tradizionale avrebbe potuto consumare un anno o più di un piccolo team di ingegneri, rallentando al contempo lo sviluppo delle funzionalità e le correzioni di sicurezza.

Claude Code ha reso possibile una migrazione completamente meccanica.

Da Zig a Rust in 11 giorni

Sumner ha utilizzato una versione pre-release di Claude Fable 5 e i flussi di lavoro dinamici di Claude Code per eseguire la migrazione.

Scrittura e revisione principali

Il processo è durato 11 giorni consecutivi. Circa 50 flussi di lavoro dinamici hanno gestito diverse fasi, tra cui:

• Creazione di una guida al porting da Zig a Rust
• Mappatura del ciclo di vita della memoria
• Conversione di file .zig in file .rs
• Revisione di ogni file generato
• Correzione degli errori del compilatore
• Ripristino dei singoli comandi di Bun
• Esecuzione della suite di test completa
• Refactoring e pulizia del codice generato

Al picco di throughput, il flusso di lavoro produceva circa 1300 righe di codice al minuto. Ogni unità di codice generata veniva controllata da due revisori antagonisti indipendenti, seguiti da un fixer che applicava le modifiche confermate.

La richiesta pull finale ha aggiunto oltre un milione di righe di codice in più di 2000 file modificati.

Prima del merge, la suite di test esistente di Bun è stata superata in CI. Dopo il merge, si sono verificati 19 problemi di regressione, che Anthropic ha dichiarato essere stati tutti risolti successivamente. Il porting in Rust è stato rilasciato con Claude Code a giugno 2026.

Questo risultato non dimostra che il milione di righe di codice inizialmente generato fosse corretto. Sumner ha chiaramente indicato che i primi output di traduzione non erano eseguibili. La chiave del successo è stato il sistema di feedback, che ha gradualmente trasformato output non eseguibili in codice compilato, testato e comportamentalmente compatibile.

Costo della migrazione: circa 165.000 dollari (ai prezzi API)

La migrazione di Bun ha consumato circa:

• 5,9 miliardi di token di input non memorizzati nella cache
• 690 milioni di token di output
• Circa 165.000 dollari ai prezzi API

È una cifra considerevole, ma ancora molto inferiore ai costi tradizionali di una migrazione che richiederebbe diversi ingegneri a tempo pieno per anni.

Anthropic stima che una migrazione di questa portata avrebbe potuto richiedere quattro anni e costare circa 3-4 milioni di dollari in risorse ingegneristiche. L'AI cambia la logica di business, perché la migrazione non deve più risolvere un problema di sopravvivenza per giustificare i suoi costi.

Errori di memoria persistenti, ecosistemi linguistici invecchiati, processi di build costosi o colli di bottiglia di manutenzione ricorrenti possono ora essere sufficienti a rendere la migrazione un'opzione da valutare.

Tuttavia, il confronto va fatto con cautela. Il costo in token non è il costo totale del progetto. Il team ha anche bisogno di pianificazione umana, infrastrutture, test, revisione del codice, lavoro di sicurezza e manutenzione post-merge.

Perché Bun è migrato da Zig a Rust

La migrazione è stata guidata principalmente da considerazioni di affidabilità, non di velocità grezza.

Bun era già performante in Zig. Il problema era come coordinare in modo sicuro la memoria nativa gestita manualmente con il runtime JavaScript con garbage collection.

Le categorie di errore comuni includevano:

• Errori di use-after-free
• Errori di double free
• Perdite di memoria su percorsi eccezionali
• Puntatori non validi causati da callback rientranti
• Codice di pulizia saltato
• Assunzioni sul ciclo di vita difficili da applicare in modo coerente

In Rust sicuro, molti di questi errori non possono essere compilati. I valori hanno una proprietà chiara, la pulizia delle risorse è legata al ciclo di vita degli oggetti e il compilatore controlla i riferimenti prima che il programma venga eseguito.

L'obiettivo della migrazione era preservare l'architettura, le strutture dati, il comportamento e le prestazioni esistenti di Bun. Era intenzionalmente più vicino a un porting meccanico che a una riprogettazione completa.

Questa decisione è stata cruciale. Se si riprogetta il sistema e si cambia linguaggio contemporaneamente, il confronto dei comportamenti diventa estremamente difficile.

Secondo caso: 165.000 righe di codice Python convertite in TypeScript

Jarred Sumner non è l'unico ingegnere Anthropic a utilizzare Claude Code per migrazioni significative.

Mike Krieger, co-responsabile di Anthropic Labs e co-fondatore di Instagram, ha convertito un codebase Python interno in circa 165.000 righe di TypeScript in un fine settimana.

Il processo di migrazione principale ha consumato circa 27 milioni di token, coinvolgendo:

• Centinaia di agenti intelligenti
• Otto fasi di check
• Tre cicli di revisione antagonistica
• Un controllo finale di coerenza
• Confronto output per comando con la versione Python
• Test end-to-end generati dall'AI

Lo strumento originale doveva essere consegnato come singolo binario. Con la toolchain Python, la compilazione richiedeva circa otto minuti per piattaforma, e la matrice di build completa ritardava ogni rilascio di circa 30 minuti.

Dopo la migrazione a TypeScript:

• Il tempo di compilazione è sceso a circa due secondi
• L'avvio del binario è circa sei volte più veloce
• È stato possibile eliminare pipeline di distribuzione separate

Krieger non aveva una suite di test cross-linguaggio completa già esistente. Invece, Claude

È stato creato un framework di test di conformità che copre sette scenari reali, dopodiché sono stati confrontati i risultati delle implementazioni vecchia e nuova.

Claude ha inoltre progettato test end-to-end aggiuntivi, eseguendoli per quattro notti consecutive e ripetendo il processo dopo aver corretto i casi falliti. Ciò ha permesso di individuare sottili differenze comportamentali che gli scenari originali non avevano previsto.

Perché le migrazioni su larga scala sono adatte agli agenti AI

Le migrazioni su larga scala incutono timore perché comportano un'enorme quantità di modifiche ripetitive. Sono proprio queste caratteristiche a renderle adatte per flussi di lavoro basati su agenti intelligenti.

Il lavoro è parallelizzabile

I grandi codebase possono solitamente essere suddivisi in file, pacchetti, crate, moduli o gruppi di dipendenze. Agenti intelligenti indipendenti possono gestire simultaneamente unità tra loro indipendenti.

Il grafo delle dipendenze determina quali unità possono procedere in parallelo e quali devono attendere.

Il codice esistente costituisce la specifica

L'implementazione originale contiene già il comportamento richiesto, i casi limite, le strutture dati e i dettagli di integrazione.

Il modello non deve creare funzionalità del prodotto; il suo compito è preservare il sistema esistente nel nuovo linguaggio o framework.

I test forniscono una valutazione oggettiva

Gli agenti intelligenti lavorano meglio quando possono valutare meccanicamente il proprio output.

Il compilatore, la suite di test, il confronto delle differenze di output, i benchmark o i framework di test di conformità forniscono segnali concreti al sistema. L'agente intelligente può così migliorare continuamente, senza bisogno di giudizio umano per ogni tentativo intermedio.

Le code di attività possono essere generate automaticamente

Gli errori di compilazione diventano il compito successivo, i test falliti diventano il compito successivo, e anche i crash del programma diventano il compito successivo.

Ciò trasforma un'enorme mole di attività di migrazione in una coda che può essere progressivamente ridotta.

I fallimenti ripetuti possono guidare il miglioramento delle regole

Quando un revisore trova lo stesso problema in più file, la soluzione migliore non è correggere manualmente ciascun file.

Bisogna aggiornare il manuale delle regole e rigenerare i lotti interessati. Questo impedisce che lo stesso errore si ripresenti nel lavoro successivo.

Principio fondamentale: correggi il processo, non i singoli file

L'idea più importante nel flusso di lavoro di Anthropic è: considera il codice generato come il prodotto di un output sistemico.

Supponiamo che 200 file tradotti contengano lo stesso errore di proprietà. Correggere manualmente questi file potrebbe risolvere gli errori visibili, ma il flusso di lavoro potrebbe comunque generare nuovamente lo stesso errore.

Un metodo più efficace è:

1. Identificare lo schema dei fallimenti ripetuti.
2. Determinare quale regola di migrazione li ha causati.
3. Aggiornare il manuale delle regole.
4. Rigenerare solo i file interessati.
5. Eseguire nuovamente il ciclo di revisione e verifica.

Il codice migliora perché il processo produttivo è stato ottimizzato.

Questo è simile all'ingegneria del software ordinaria. Un difetto di produzione ricorrente dovrebbe portare a migliorare test, regole di tipo, controlli statici o processi, non solo a applicare un'altra patch isolata.

Prerequisito: costruire un meccanismo di valutazione affidabile

Prima di iniziare una migrazione su larga scala, è necessario definire come il team dimostrerà la correttezza della nuova implementazione.

Senza un meccanismo di valutazione, non è possibile determinare una condizione di completamento affidabile.

Il meccanismo di valutazione deve valutare l'implementazione originale e quella target nelle stesse condizioni. I test esistenti potrebbero dipendere da funzioni private o meccanismi interni specifici del linguaggio, che scompaiono durante il porting.

Anthropic raccomanda tre fasi preparatorie:

1. Classificare i test esistenti. Separare i test che verificano il comportamento pubblico da quelli che dipendono dall'implementazione interna.
2. Riscrivere i test per la portabilità. Trasformare il comportamento osservabile esternamente in asserzioni che possano funzionare su entrambi i sistemi.
3. Validare il meccanismo di valutazione. Confermare che l'implementazione originale superi i test, quindi rompere intenzionalmente il programma e verificare che il meccanismo di valutazione fallisca.

Una suite di test che non rileva guasti noti non può essere utilizzata come valido meccanismo di valutazione per una migrazione.

Bun ha un vantaggio significativo: la maggior parte della sua suite di test è scritta in TypeScript, non in Zig, quindi la stessa suite può testare l'implementazione in Rust.

Per i progetti senza questo vantaggio, è possibile utilizzare strumenti di test tra pari per confrontare input e output effettivi tra le due versioni.

Il framework di migrazione in sei fasi di Anthropic

Anthropic ha riassunto l'esperienza di questi progetti nel seguente processo in sei fasi.

Immagine che illustra il framework di migrazione in sei fasi proposto da Anthropic. Il primo passo è creare mappe e regole, inclusi autori del manuale, mappatori di dipendenze, inventario delle lacune, ecc.; il secondo passo è testare le regole sotto stress, con doppi traduttori, verificatori delle differenze, ecc.; il terzo passo è tradurre tutto, con implementatori, revisori, ecc.; il quarto passo è compilare, con indagini sulla build, riparatori paralleli, ecc.; il quinto passo è eseguire, con test fumogeni, riparatori, ecc.; il sesto passo è far corrispondere il comportamento, con demoni di build, riparatori, ecc. Nella parte inferiore sono elencati anche documenti condivisi, infrastruttura di esecuzione, ecc. L'immagine è una visualizzazione del framework di migrazione in sei fasi di Anthropic descritto sopra.

Primo passo: creare il manuale delle regole, il grafo delle dipendenze e l'inventario delle lacune

La prima fase crea i documenti condivisi che tutti gli agenti successivi seguiranno.

Costruire il manuale delle regole

Il manuale delle regole definisce come i concetti del linguaggio sorgente si mappano nel linguaggio target.

Per migrazioni che mantengono la struttura invariata, il manuale può includere:

• Mappatura dei tipi
• Gestione degli errori

Convenzioni del manuale

• Regole di denominazione
• Regole di memoria e proprietà
• Specifiche per la sostituzione della libreria standard
• Pattern di concorrenza
• Layout di file e moduli
• Regole per l'interfaccia con funzioni esterne
• Pattern che richiedono revisione umana

Nelle migrazioni di refactoring, il manuale delle regole è più simile a un documento di architettura.

Jarred Sumner, dialogando con Claude e tramite revisione manuale, ha redatto la guida al porting di Bun. Il prodotto finale è lungo centinaia di righe.

Creare una mappa delle dipendenze

Il repository deve essere suddiviso in ordine di dipendenze.

Uno script deterministico può generare una mappa delle dipendenze esaminando import, manifesti, file di build e relazioni tra simboli. Il risultato aiuta l'orchestratore a determinare quali file possono essere convertiti indipendentemente e quali devono essere gestiti insieme.

Redigere l'inventario delle lacune

Il linguaggio sorgente e quello target seguono regole diverse.

Per una migrazione da Zig a Rust, la proprietà della memoria è la principale lacuna. Per una migrazione da Python a TypeScript, la forma implicita degli oggetti e le interfacce devono essere trasformate in contratti espliciti.

L'inventario delle lacune deve registrare gli aspetti che la semplice traduzione non può risolvere, inclusi:

• Assunzioni implicite del linguaggio sorgente
• Astrazioni mancanti nel linguaggio target
• Comportamenti a runtime da esplicitare
• Librerie non supportate
• Codice specifico della piattaforma
• Boundary non sicuri
• Aree che richiedono riprogettazione o decisioni umane

Il manuale delle regole dovrebbe essere creato prima dell'inventario delle lacune, poiché quest'ultimo dipende in parte da ciò che le regole ordinarie non possono gestire.

Secondo passo: testare le regole sotto stress

Non tradurre migliaia di file immediatamente.

Seleziona prima una piccola esecuzione di prova con alcuni file complessi e rappresentativi. L'obiettivo è individuare i difetti nelle regole prima che si diffondano in tutto il repository.

Nell'esecuzione di prova di Bun:

1. Il primo agente ha tradotto tre file seguendo il manuale delle regole.
2. Un altro agente, dal punto di vista di un ingegnere Rust senior, ha tradotto gli stessi file.
3. Un agente di confronto ha verificato le differenze.
4. I revisori hanno segnalato regole di migrazione mancanti o errate.
5. I file tradotti sono stati scartati.

Il prodotto di questa fase è un manuale delle regole ottimizzato, non codice di produzione.

Per migrazioni di refactoring, il test equivalente consiste nel far attaccare il documento di progettazione da un revisore antagonista, quindi eseguire un'unica esecuzione end-to-end.

Terzo passo: traduzione completa

Una volta che le regole sono state validate nell'esecuzione di prova, il repository può essere elaborato attraverso code parallele.

La configurazione tipica di un'unità include:

• Un implementatore
• Due revisori antagonisti indipendenti
• Un riparatore
• Una coda meccanica
• Un manuale delle regole condiviso
• Un inventario delle lacune condiviso

La coda deve supportare il ripristino da interruzioni. Deve essere in grado di determinare lo stato di completamento del lavoro controllando i file o registrando gli artefatti, senza dipendere dalla memoria di un singolo agente.

Gli agenti dovrebbero sempre marcare in modo coerente il lavoro non completato, ad esempio:

TODO(porting): Spiegare perché questa parte non può essere tradotta in modo sicuro

Non è necessario utilizzare il modello più costoso per ogni unità. Modelli di fascia inferiore possono gestire traduzioni ad alto volume, mentre modelli più potenti possono essere riservati a revisori, decisioni architetturali e modifiche alle regole.

Quarto passo: compilazione

La prima build completa trasforma gli errori del compilatore in una coda di lavoro strutturata.

A seconda del costo della build, il compilatore può essere eseguito all'interno di ogni ciclo dell'agente o tramite un orchestratore separato.

Per il progetto Bun, compilare l'intero workspace è costoso, quindi durante la traduzione dei file, l'agente Claude non esegue comandi cargo arbitrariamente. Il flusso alternativo è:

1. L'orchestratore esegue il compilatore.
2. I messaggi di errore vengono scritti in un elenco condiviso.
3. L'elenco viene classificato per modulo o causa principale.
4. Gli agenti di riparazione gestiscono in parallelo i gruppi di errori.
5. I revisori controllano le correzioni.
6. L'orchestratore ricostruisce il progetto.

Questo impedisce a decine di agenti di avviare contemporaneamente build ugualmente costose.

Gli errori del compilatore di sistema dovrebbero far aggiornare le regole. Ad esempio, il linguaggio di destinazione potrebbe rifiutare le dipendenze cicliche che il compilatore di origine tollera con un caricamento pigro. Questo è un problema a livello di processo, non semplicemente un insieme isolato di errori di file.

Passo 5: Eseguire il programma

Una compilazione riuscita dimostra solo che il linguaggio di destinazione accetta il codice.

La fase successiva, tramite esecuzioni di base e test di fumo, consente di individuare crash, errori di inizializzazione, risorse mancanti, ipotesi non valide e guasti d'integrazione.

I casi di fallimento dovrebbero comunque essere classificati per causa.

Se 40 test di fumo falliscono a causa dello stesso schema di inizializzazione errato, è necessario correggere la regola di migrazione e rigenerare il codice interessato, anziché assegnare 40 soluzioni indipendenti.

Passo 6: Abbinare il comportamento originale

L'ultimo ostacolo è la coerenza di comportamento.

Eseguire contemporaneamente le suite di test portabili di entrambi i codebase, gli strumenti di verifica della conformità, il confronto degli output e i benchmark correlati.

Per ogni caso di fallimento:

1. Fornire all'agente di correzione le prove del fallimento e due opzioni di implementazione.
2. Richiedere all'agente di correzione di identificare la differenza di comportamento.
3. Un revisore antagonista esamina le modifiche proposte.
4. Gestire in batch le build costose tramite un unico processo di compilazione.
5. Rieseguire i test interessati.
6. Promuovere i fallimenti ricorrenti a cambiamenti delle regole.

Il codebase originale è sempre il punto di riferimento, a meno che il progetto non intenda esplicitamente cambiare il comportamento.

L'assenza di una suite di test non consente di saltare questo passaggio. Il team può creare strumenti esterni di verifica della conformità basati su scenari reali con l'aiuto di Claude, e convalidare l'efficacia di questi strumenti tramite comportamenti deliberatamente compromessi.

Guida introduttiva al kit di migrazione Anthropic

Anthropic ha rilasciato un kit di migrazione introduttivo pubblico, contenente prompt generici, modelli e script basati sul flusso di migrazione.

Questo repository è un materiale di riferimento, non un prodotto di migrazione completamente gestito. I suoi prompt sono modelli di refactoring, non la registrazione esatta del flusso di lavoro del progetto Bun.

1. Installare Claude Code

Su sistemi macOS o Linux:

curl -fsSL https://claude.ai/install.sh | bash

Su sistemi Windows PowerShell:

irm https://claude.ai/install.ps1 | iex

Prima di eseguire script di installazione remoti, esaminare il contenuto dello script e le policy di sicurezza della propria organizzazione.

2. Clonare il kit di migrazione

Nel repository da migrare, eseguire:

git clone https://github.com/anthropics/code-migration-kit-with-claude-code.git ./migration-kit

3. Aggiungere la skill di migrazione

Questo passaggio facoltativo copia la skill di migrazione nella directory locale delle skill di Claude Code:

cp -r migration-kit/skill ~/.claude/skills/code-migration

Seguire le istruzioni per aggiornare il percorso del kit nella SKILL.md installata.

Repository.

4. Eseguire la valutazione di fattibilità

Innanzitutto, utilizzare il prompt di fattibilità di sola lettura del kit:

prompts/00-feasibility.md

I risultati dovrebbero rispondere a tre domande:

• Questo progetto dovrebbe essere migrato?
• La migrazione manterrà la struttura invariata o la riprogetterà?
• L'implementazione originale e quella di destinazione possono essere giudicate equamente?

"Non migrare" è un risultato valido.

5. Preparare gli strumenti di giudizio e le regole di sicurezza

Prima di avviare la traduzione:

• Costruire o convalidare strumenti di giudizio multilingua.
• Copiare le impostazioni consigliate di Claude nel repository di destinazione.
• Vietare comandi distruttivi o costosi, ove appropriato.
• Confermare che il repository di origine disponga di un backup ripristinabile.
• Utilizzare branch isolati, working tree controllati e credenziali con privilegi minimi.

Eseguire quindi i prompt di migrazione in sequenza, senza saltare direttamente alla traduzione su larga scala.

Problemi emersi nei primi tentativi di Bun

La migrazione di Bun non è iniziata bene.

Quando molti agenti iniziano a lavorare in un unico repository, le loro operazioni Git interferiscono tra loro. Un agente esegue git stash, un altro usa git stash pop, e un altro ancora resetta il working tree.

Sumner ha modificato il flusso di lavoro, impedendo agli agenti di eseguire liberamente comandi Git distruttivi. Successivamente ha suddiviso il lavoro in quattro frammenti di flusso di lavoro, ciascuno con un working tree indipendente, coordinando più agenti.

Questo esempio evidenzia un punto cruciale: i permessi degli agenti devono corrispondere alla progettazione del flusso di lavoro.

Un agente di codifica con ampio accesso alla shell potrebbe:

• Eliminare o sovrascrivere il lavoro
• Resettare le modifiche non salvate
• Attivare ripetutamente build costose
• Modificare file non pertinenti
• Divulgare segreti tramite comandi o log
• Interferire con altri agenti

Il livello di orchestrazione deve limitare i comandi, definire la proprietà dei file, serializzare le operazioni costose e rendere semplice il ripristino.

Best practice per la migrazione di codice assistita dall'AI

Le lezioni apprese da Anthropic possono essere riassunte in alcune regole pratiche.

Non seguire ciecamente guide generiche

Ogni codebase ha sistemi di build, copertura di test, comportamento runtime, vincoli di distribuzione e tolleranza al rischio diversi.

Usare il framework in sei fasi come punto di partenza, quindi lasciare che Claude lo adatti al repository reale.

Concentrarsi sui modelli, non sui singoli fallimenti

Gli agenti di correzione possono gestire i singoli fallimenti. Il valore umano è maggiore quando l'attenzione è rivolta all'identificazione di modelli ricorrenti, regole mancanti, ipotesi non sicure e problemi architetturali.

Rendere la revisione antagonista

L'agente di implementazione non dovrebbe essere il suo unico revisore.

Fornire al revisore un contesto indipendente e comunicargli che si presuppone che il codice generato sia errato. Il suo compito è scoprire perché il codice fallisce, si discosta o viola il manuale delle regole.

Rendere la verifica meccanica

Utilizzare compilatori, test, linter, differenze di output, benchmark e script deterministici come strumenti di giudizio.

Una revisione soggettiva del tipo "sembra corretto" non può verificare in modo sicuro modifiche di milioni di righe.

Utilizzare modelli diversi per ruoli diversi

I compiti di traduzione ad alto volume possono essere affidati a modelli più piccoli o meno costosi. Il modello più potente dovrebbe occuparsi di creazione di regole, architettura, fallimenti ambigui e revisione.

Investire presto risorse umane

Il lavoro umano di maggior valore dovrebbe essere completato prima della generazione su larga scala:

Definire il business case

• Costruire meccanismi di revisione
• Creare il manuale delle regole
• Mappare le dipendenze
• Verificare i progetti pilota
• Impostare permessi e confini

Una volta che queste basi sono solide e affidabili, la maggior parte del lavoro rimanente diventa una serie di attività meccaniche in coda.

Mantenere la coda ripristinabile

Le attività di migrazione che richiedono giorni di esecuzione devono essere in grado di resistere a crash, riavvii, errori del modello e interruzioni dell'infrastruttura.

Lo stato di completamento deve basarsi su artefatti persistenti su disco, commit, risultati di test e stato della coda, non su un'unica lunga conversazione.

Risultati dopo la migrazione di Bun

Anthropic ha riferito che il codice Bun, scritto in Rust, è stato utilizzato in produzione.

Questa migrazione non ha eliminato tutti i compromessi. Circa il 4% del codice Rust risiede ancora in blocchi unsafe, concentrato principalmente in piccole operazioni su puntatori ai confini con C e C++.

Tuttavia, la nuova implementazione ha portato notevoli miglioramenti:

• Risolti problemi di perdita di memoria rilevabili
• Il consumo di memoria in un benchmark di build ripetuta è passato da 6.745 MB a 609 MB
• La dimensione del binario è stata ridotta del 19% su piattaforme Linux e Windows
• Ottimizzazioni cross-linguaggio hanno migliorato le prestazioni di carichi di lavoro specifici di circa il 2% - 5%

Questi risultati dimostrano chiaramente il significato della migrazione. L'obiettivo non è generare grandi quantità di codice scritto dall'AI, ma creare un sistema più sicuro, snello e manutenibile, mantenendo il comportamento originale.

Scenari applicabili per la migrazione AI

Quando si verificano le seguenti condizioni, la migrazione su larga scala è adatta per flussi di lavoro basati su agenti:

• Il codebase originale può essere utilizzato come specifica completa
• Il comportamento è verificabile con mezzi esterni
• È possibile creare test o scenari di confronto
• Il lavoro può essere suddiviso in unità ripetibili
• Il linguaggio di destinazione presenta vantaggi evidenti
• L'organizzazione tollera branch sperimentali di grandi dimensioni
• Esperti umani possono esaminare architettura e casi limite
• L'ambiente degli strumenti è limitabile e verificabile

Potrebbe non essere adatto, invece, quando:

• La comprensione del comportamento originale è insufficiente
• La correttezza non è verificabile
• Il progetto confonde migrazione e riprogettazione completa del prodotto
• L'approvazione normativa richiede la verifica umana di ogni modifica
• Il codice contiene segreti o sistemi che non possono essere esposti in sicurezza
• Il team non ha la titolarità del codice generato dall'AI dopo l'unione

Essere in grado di generare rapidamente milioni di righe di codice non rende la migrazione automaticamente ragionevole.

Domande frequenti

Claude Code ha davvero convertito Bun da Zig

È stato riscritto in Rust?

Sì. Jarred Sumner ha utilizzato il flusso di lavoro dinamico di Claude Code e il modello Claude in versione pre-release per migrare il core di Bun da Zig a Rust. Il processo ha generato oltre un milione di righe di codice in meno di due settimane, seguite da compilazione, test, revisione e correzioni post-unione.

Quanto è costata la migrazione di Bun?

Anthropic riporta un consumo di circa 5,9 miliardi di token di input non memorizzati nella cache e 690 milioni di token di output. Basandosi sui prezzi API, il costo del modello è stato stimato intorno ai 165.000 dollari, senza contare le spese per personale e infrastrutture.

La migrazione ha superato tutti i test prima dell'unione?

Anthropic afferma che, prima dell'unione, la suite di test esistente di Bun è stata superata nel CI. Dopo l'unione sono emersi 19 problemi di regressione, successivamente risolti.

Perché Bun è passato da Zig a Rust?

L'obiettivo principale era migliorare la sicurezza della memoria, riducendo i continui problemi relativi alla durata del ciclo di vita, alla pulizia della memoria, ai double free e alle perdite di memoria. Il sistema di ownership e i tipi di Rust riescono a individuare molti di questi problemi in fase di compilazione.

Claude Code può migrare automaticamente qualsiasi codebase?

No. Una migrazione di successo richiede giudici rigorosi, regole chiare, analisi delle dipendenze, permessi controllati, code ripetibili, revisioni contrastive e supervisione umana. Alcuni progetti non dovrebbero essere migrati affatto.

Cos'è una revisione del codice contrastiva?

I revisori contrastivi ricevono le modifiche generate in un ambiente indipendente e il loro compito è trovare difetti, non approvare le modifiche. Il ruolo dell'implementatore è separato da quello del revisore, riducendo il rischio che l'autore difenda il proprio output.

È necessaria una suite di test esistente?

Idealmente, è consigliabile disporre di una suite di test completa, specialmente se in grado di testare il comportamento pubblico indipendentemente dal linguaggio di implementazione. In mancanza di ciò, il team può costruire un framework di validazione per confrontare scenari reali e output tra il vecchio e il nuovo sistema.

Il kit di migrazione di Anthropic è esattamente il flusso di lavoro usato per Bun?

No. Anthropic descrive il repository come un kit di partenza generalizzato e riprogettato. La migrazione effettiva di Bun ha utilizzato componenti più specifici, tra cui un lungo manuale di regole per il progetto e flussi di lavoro dinamici personalizzati.

Strumenti correlati

• Claude Code: Lo strumento di codifica intelligente di Anthropic per la gestione di repository, terminali, test e flussi di lavoro di sviluppo.
• Bun: Runtime per JavaScript e TypeScript, gestore di pacchetti, bundler ed esecutore di test.
• Rust: Linguaggio di programmazione di sistema incentrato su prestazioni, sicurezza dei tipi e della memoria.
• Zig: Linguaggio di programmazione a basso livello che enfatizza il controllo esplicito e la semplicità semantica.
• GitHub: Piattaforma di controllo versione e collaborazione per gestire le richieste di pull della migrazione di Bun e il kit di migrazione di Anthropic.
• Plugin di modernizzazione Claude Code: Plugin ufficiale di Anthropic per valutare e modernizzare sistemi legacy.

Link correlati

• Guida alla migrazione su larga scala di Anthropic: Processo ufficiale in sei fasi e due casi studio di migrazione.
• Riscrittura di Bun in Rust: Resoconto dettagliato di Jarred Sumner su architettura, flusso di lavoro, revisione, fallimenti e risultati.
• Richiesta di pull per la riscrittura di Bun in Rust: Richiesta di pull unita che include la migrazione su larga scala da Zig a Rust.
• Kit di migrazione Claude Code: Prompt ufficiali, template, script e flussi di lavoro di riferimento per la migrazione linguistica.
• Documentazione di Claude Code: Documentazione ufficiale su installazione, configurazione, sicurezza e flussi di lavoro.
• Plugin di modernizzazione del codice: Plugin ufficiale di Claude Code per la valutazione e trasformazione di sistemi legacy.

Test di equivalenza comportamentale.

• Guida ufficiale di Rust: Documentazione ufficiale che copre ownership, borrowing, tipi, concorrenza e sviluppo applicativo in Rust.

Riepilogo

Il successo della migrazione di Bun con Claude Code non è dovuto alla generazione perfetta di un milione di righe di codice in un'unica soluzione. La chiave del progetto è stata la capacità del team di costruire attorno al modello un sistema di produzione rigoroso: manuale di regole, mappatura delle dipendenze, elenco di lacune, progetto pilota, coda di traduzione parallela, revisione contrastiva, ciclo del compilatore, test di fumo e verifica di coerenza comportamentale.

Lo stesso approccio ha aiutato Anthropic a migrare un grande codebase Python verso TypeScript in un fine settimana. In entrambi i casi, l'importanza della verifica oggettiva ha superato di gran lunga la velocità di generazione iniziale.

L'IA può ridurre significativamente i costi e i tempi delle migrazioni su larga scala, ma solo se il processo è interrompibile e ripristinabile, i permessi sono controllati e i difetti ricorrenti portano a un miglioramento continuo delle regole di generazione del codice.

La vera svolta non è che l'IA possa scrivere un milione di righe di codice, ma che un ciclo accuratamente progettato possa generare, mettere in discussione, testare e correggere ripetutamente questo codice, fino a quando il comportamento del nuovo sistema non corrisponde esattamente a quello del vecchio.