Flusso di lavoro per la migrazione del linguaggio del codice di Claude: il metodo in sei passi di Anthropic per basi di codice di grandi dimensioni
Cambiare il linguaggio principale di una base di codice di produzione matura è stato a lungo il tipo di progetto che i team rimandavano per anni. Questo lavoro è costoso, rischioso e difficile da valutare. Una singola migrazione può consumare diversi trimestri di ingegneria, durante i quali le due versioni implementative divergono gradualmente, e al completamento il comportamento non è ancora del tutto coerente. Un recente progetto interno di Anthropic mostra che questa situazione sta iniziando a cambiare. Nel luglio 2026, Anthropic ha pubblicato un rapporto pratico che descrive come i suoi sviluppatori utilizzano
Come Anthropic ha realizzato una migrazione su larga scala con Claude Code
Introduzione
Cambiare il linguaggio principale di un codebase di produzione maturo era un tempo il tipo di progetto che i team rimandavano per anni. Il lavoro è costoso, rischioso e difficile da stimare. Una singola migrazione poteva consumare diversi trimesti di ingegneria, durante i quali le due implementazioni si allontanavano sempre più, per poi ottenere solo una conformità comportamentale incompleta.
Un recente progetto interno di Anthropic dimostra che questa situazione sta iniziando a cambiare.
Nel luglio 2026, Anthropic ha pubblicato un rapporto pratico che descrive in dettaglio come i suoi sviluppatori hanno utilizzato Claude Code, Claude Fable 5, Claude Opus 4.8 e un flusso di lavoro multi-agente dinamico per migrare dieci pacchetti di codice in circa un mese. Questi pacchetti contenevano da decine di migliaia a centinaia di migliaia di righe di codice.
Due casi sono particolarmente degni di nota:
- Jarred Sumner, co-fondatore di Bun, ha utilizzato Claude Code per migrare Bun da Zig a Rust, generando oltre un milione di righe di codice in meno di due settimane.
- Mike Krieger, co-responsabile di Anthropic Labs, ha convertito un codebase Python in circa 165.000 righe di codice TypeScript in un fine settimana.
L'importante rivelazione non è che i modelli AI possano tradurre rapidamente i file, ma che un sistema di migrazione ben progettato può generare, rivedere, testare, respingere e rigenerare codice ripetutamente con un intervento umano minimo.
Anthropic riassume la sua filosofia in questo modo: il compito principale dello sviluppatore non è correggere manualmente ogni errore generato, ma migliorare quel processo che continuamente produce errori.
Due migrazioni che cambiano il calcolo dei costi
Bun: la migrazione di oltre un milione di righe da Zig a Rust
Bun è un toolkit integrato per JavaScript e TypeScript che include runtime, gestore di pacchetti, bundler, test runner e altri strumenti di sviluppo. La sua implementazione originale si basava fortemente su Zig e si integrava con una grande quantità di codice C e C++.
Jarred Sumner ha utilizzato circa 50 flussi di lavoro dinamici di Claude Code in 11 giorni per completare la migrazione a Rust. La richiesta pull unita conteneva oltre un milione di righe di codice nuovo e migliaia di commit.
Prima dell'unione, la suite di test di integrazione continua esistente di Bun superava tutti i test sulle sue piattaforme supportate. Anthropic ha successivamente riferito che dopo l'unione sono emersi 19 problemi di regressione, poi risolti.
Questa migrazione non è stata una riprogettazione da zero. L'obiettivo era mantenere l'architettura e il comportamento esistenti di Bun, sostituendo al contempo il linguaggio di implementazione. Ciò ha ridotto le variabili in gioco: il progetto poteva concentrarsi sulla semantica del linguaggio, la proprietà, la sicurezza della memoria e la compatibilità, anziché ricostruire il prodotto da capo.
Il rapporto ufficiale di Bun spiega perché Rust è stato attraente. Molti problemi di stabilità ricorrenti riguardavano la gestione del ciclo di vita, i percorsi di pulizia mancati, l'uso dopo il rilascio e il rischio di doppio rilascio. In Rust sicuro, molti di questi problemi diventano errori in fase di compilazione, anziché essere scoperti solo attraverso crash in produzione, fuzz test o revisioni manuali.
Migrazione da Python a TypeScript in un fine settimana
Il progetto di Mike Krieger ha seguito una strada diversa. Questa migrazione non ha cercato di preservare il più possibile la struttura originale dei file, ma ha comportato una maggiore riprogettazione architettonica.
Il risultato è stata la generazione di circa 165.000 righe di codice TypeScript in un fine settimana. Secondo quanto riportato, il processo ha utilizzato:
- Centinaia di agenti.
- Otto fasi di controllo.
- Tre cicli di revisione antagonistica.
- Un framework di test di conformità per confrontare l'output di ogni comando con l'implementazione Python.
La ragione aziendale era chiara. Questo strumento interno basato su Python veniva distribuito come singolo binario, ma la generazione di quel binario richiedeva circa otto minuti per ogni piattaforma, e circa 30 minuti per l'intera matrice di rilascio.
Dopo la migrazione, la compilazione richiede circa due secondi, la velocità di avvio è aumentata di sei volte e il team ha potuto eliminare una pipeline di distribuzione separata.
Quando vale la pena considerare una migrazione linguistica
La migrazione di linguaggio richiede ancora una vera ragione ingegneristica o aziendale. Una generazione di codice più rapida non significa che ogni riscrittura sia giustificata.
I team di solito riconsiderano la scelta del linguaggio quando l'ambiente circostante il sistema è cambiato dalla sua creazione. I fattori scatenanti tipici includono:
- I compromessi noti sono diventati problemi operativi ricorrenti.
- Il linguaggio o l'ecosistema aggiornato ora offre un miglior supporto strumentale.
- L'ecosistema originale si sta riducendo o è difficile trovare talenti.
- I requisiti di sicurezza o sicurezza della memoria sono cambiati.
- Le prestazioni di compilazione, distribuzione o runtime sono diventate un collo di bottiglia.
- Mantenere la compatibilità richiede soluzioni alternative sempre più costose.
L'uso iniziale di Zig da parte di Bun aveva senso: per un fondatore che costruiva da solo un runtime molto ampio prima dell'emergere degli agenti di codifica contemporanei, questo linguaggio offriva un controllo di basso livello che aiutava Jarred Sumner ad avanzare rapidamente.
Alcuni anni dopo, Bun è diventato uno strumento di produzione ampiamente utilizzato, con una base di manutenzione molto più ampia. Il costo dei difetti di memoria ricorrenti è aumentato, e Claude Code ha reso il porting meccanico abbastanza fattibile per essere testato.
Pertanto, la decisione non è stata "Zig è cattivo e Rust è buono", ma che le dimensioni attuali di Bun, le esigenze operative e gli strumenti disponibili hanno cambiato i compromessi.
La migrazione è più veloce, ma non a costo zero
La migrazione linguistica assistita da AI può ancora essere costosa.
Anthropic ha riferito che il progetto Bun ha consumato circa:
| Categoria di utilizzo | Quantità riportata |
|---|---|
| Token di input non memorizzati nella cache | 5,9 miliardi |
| Token di output | 690 milioni |
| Equivalente prezzo API stimato | Circa $165.000 |
La parte principale della migrazione da Python a TypeScript di Mike Krieger ha utilizzato circa 27 milioni di token.
Queste cifre sono molto inferiori ai costi ingegneristici delle migrazioni tradizionali di anni, ma non sono trascurabili. I team devono anche considerare:
- Supervisione umana.
- Costi di calcolo e API.
- Infrastruttura di test.
- Capacità CI.
- Macchine di build.
- Revisione e riparazione post-unione.
- Costi opportunità durante la migrazione.
- Manutenzione a lungo termine dell'implementazione nel linguaggio target.
La riduzione dei costi rende più progetti finanziariamente fattibili, ma non elimina la necessità di un caso aziendale.
Perché le migrazioni su larga scala si adattano così bene agli agenti AI
Le migrazioni linguistiche su larga scala possiedono diverse caratteristiche che le rendono particolarmente adatte alla collaborazione con agenti di codifica.
Il lavoro è parallelizzabile
La migrazione coinvolge spesso centinaia o migliaia di file, moduli, pacchetti o librerie che, una volta comprese le loro dipendenze, possono essere elaborati indipendentemente.
Gli agenti possono tradurre unità indipendenti in parallelo, invece di aspettare un singolo flusso di implementazione centrale. La sfida passa dalla velocità di digitazione all'orchestrazione, alla coerenza e alla verifica.
Il vecchio codice funge da specifica dettagliata
Molti compiti software iniziano con requisiti incompleti. La migrazione linguistica parte invece da un punto di partenza molto più forte: l'implementazione originale.
Il codice sorgente esistente definisce il flusso di controllo, le strutture dati, i casi limite, il comportamento in errore, le API pubbliche e la gestione specifica della piattaforma. Quando le regole di migrazione non sono chiare, gli agenti possono sempre fare riferimento all'implementazione originale.
I test forniscono un arbitro oggettivo
Gli agenti funzionano meglio quando il successo o il fallimento possono essere verificati meccanicamente.
I compilatori, le suite di test, gli script di conformità, i benchmark o i confronti deterministici dell'output forniscono un'unica fonte di verità per il flusso di lavoro. Invece di chiedere ai revisori se la nuova implementazione "sembra corretta", il sistema confronta ripetutamente il comportamento con l'implementazione originale.
I fallimenti si trasformano automaticamente in attività da completare
Errori del compilatore, crash, fallimenti dei test e differenze di output descrivono naturalmente il lavoro rimanente.
Il sistema di migrazione non ha bisogno che gli umani creino singoli ticket di attività.
Ogni controllo fallito può essere classificato e assegnato a un agente di correzione.
Gli errori ripetuti possono essere risolti a monte
Quando lo stesso problema appare in più file, correggere manualmente uno per uno non è l'approccio corretto.
La soluzione migliore è aggiornare la regola di migrazione che ha causato l'errore, quindi rigenerare solo le unità interessate. Questo trasforma un difetto trovato in un miglioramento permanente del processo.
Prerequisito: costruire un arbitro affidabile
Prima di tradurre il codice di produzione, è necessario creare un sistema di verifica in grado di valutare le implementazioni vecchie e nuove nelle stesse condizioni.
Senza un arbitro affidabile, il progetto non ha una definizione credibile di completamento.
Le suite di test scritte nella lingua originale potrebbero dipendere da funzioni private, classi interne o dettagli implementativi inesistenti nella lingua di destinazione. Questi test non possono sempre essere migrati direttamente.
Anthropic suggerisce di preparare il sistema arbitro in tre fasi.
1. Classificare i test esistenti
Distinguere i test che esprimono il comportamento esterno da quelli che dipendono da dettagli implementativi interni.
I test esterni riguardano solitamente il comportamento della riga di comando, le API pubbliche, i file, la rete, gli output osservabili o gli scenari applicativi completi. Questi contenuti sono più portabili tra linguaggi diversi.
2. Riscrivere i test per la portabilità
Convertire i test orientati al comportamento in asserzioni che possano essere eseguite su entrambe le versioni.
Utilizzare revisori avversari indipendenti per garantire che i test riscritti non siano più deboli della versione originale. Test più facili da superare potrebbero nascondere problemi di compatibilità.
3. Verificare il sistema di giudizio stesso
Eseguire il sistema di giudizio sull'implementazione originale per confermare che funzioni.
Quindi rompere intenzionalmente il programma per confermare che il sistema di giudizio fallisca. Se un sistema di verifica non riesce a rilevare difetti noti, non è pronto per supervisionare la migrazione.
Mike Krieger non ha creato da zero una suite di test completamente portabile. Il suo team ha creato un framework di test di coerenza che copre sette scenari reali, trattando qualsiasi differenza tra Python e TypeScript come un difetto.
Flusso di migrazione del codice Claude in sei passaggi
Primo passo: creare un manuale di regole, un grafo delle dipendenze e un inventario delle lacune
Il primo passo getta le fondamenta che tutti gli agenti successivi utilizzeranno.
Costruire prima il manuale di regole
Il manuale di regole descrive come la lingua sorgente deve essere mappata alla lingua di destinazione.
La sua forma dipende dalla strategia di migrazione.
Per le migrazioni che preservano la struttura, il manuale di regole può contenere:
- Mappatura dei tipi.
- Mappatura della gestione degli errori.
- Regole di proprietà.
- Convenzioni di denominazione.
- Sostituzioni per la libreria standard.
- Pattern per l'interfaccia con funzioni esterne.
- Regole per le operazioni asincrone.
- Istruzioni per costrutti non supportati.
Per una riprogettazione, il manuale di regole è più simile a un documento di architettura. Definisce i nuovi confini dei componenti, le interfacce, i contratti di dati e le decisioni di progettazione che gli agenti di implementazione devono seguire.
L'ordine è importante. Il manuale di regole deve essere scritto prima dell'inventario delle lacune, perché quest'ultimo registra tutto ciò che le regole predefinite non possono gestire in sicurezza.
Mappare le dipendenze
Il lavoro parallelo è sicuro solo quando il flusso di lavoro capisce quali unità dipendono l'una dall'altra.
Il grafo delle dipendenze aiuta a determinare:
- Quali moduli devono essere migrati per primi.
- Quali file appartengono allo stesso lotto.
- Quali interfacce devono essere stabilizzate prima che il lavoro a valle possa iniziare.
- Quali cicli richiedono una gestione speciale.
- Quali agenti paralleli potrebbero generare conflitti.
Alcuni linguaggi espongono le informazioni sulle dipendenze tramite manifesti di pacchetto o metadati dei moduli. I sistemi C, C++ e Python più datati potrebbero aver bisogno di script di analisi deterministici per scoprire il grafo delle dipendenze.
Claude Code può aiutare a creare ed eseguire questi script, ma il grafo generato deve essere prodotto meccanicamente, non indovinato solo dall'output del modello.
Registrare le lacune linguistiche e architetturali
L'inventario delle lacune cattura le differenze che non possono essere gestite tramite traduzione diretta.
Per una migrazione da Zig a Rust, le lacune importanti includono la proprietà e il ciclo di vita della memoria. Zig consente che alcune responsabilità di pulizia vengano comunicate tramite convenzioni o commenti, mentre Rust richiede che i vincoli di proprietà siano espressi nel sistema dei tipi.
Per un lavoro di migrazione da Python a TypeScript, la definizione delle interfacce è una lacuna principale. Python di solito accetta oggetti in base al comportamento a runtime, mentre TypeScript richiede contratti espliciti prima che il codice possa essere compilato in sicurezza.
L'inventario deve essere considerato un artefatto aggiornato dinamicamente. Nuove lacune emergono continuamente durante la traduzione, la compilazione e i test di conformità.
Secondo passo: stress test delle regole tramite mini-migrazioni una tantum
Non applicare subito il nuovo manuale di regole a migliaia di file.
Eseguire prima una piccola migrazione, quindi scartare deliberatamente l'output.
Per Bun, il test ha coinvolto un piccolo numero di file:
- Un agente traduce i file secondo il manuale di regole.
- Un altro agente traduce file comparabili come farebbe un ingegnere Rust esperto.
- Un terzo agente confronta i risultati e propone regole più solide.
- Revisori avversari cercano problemi comportamentali o strutturali.
Prima di applicare effettivamente la migrazione a tutti i 1.448 file Zig, questo lavoro ha esposto due problemi gravi.
Le migrazioni che mantengono invariata la struttura rendono questo confronto relativamente facile, poiché due implementazioni dello stesso file possono essere esaminate fianco a fianco.
Per una riprogettazione, lo stress test dovrebbe concentrarsi sul documento di architettura. Gli agenti avversari possono attaccarne le ipotesi, quindi un'esecuzione end-to-end una tantum per esporre interfacce mancanti e ordini irrealistici.
L'obiettivo è migliorare il manuale di regole, non accumulare codice di produzione. Una volta individuati i punti deboli, i file generati vengono scartati.
Terzo passo: tradurre l'intero codebase
Dopo che le regole hanno superato lo stress test, il lavoro di traduzione può essere esteso all'intero repository.
Anthropic descrive un ciclo ripetitivo composto da tre ruoli:
- Realizzatore: genera il codice tradotto.
- Revisore antagonista: cerca difetti e violazioni delle regole.
- Correttore: applica il feedback di revisione accettato.
Il lavoro di realizzazione può spesso essere svolto con modelli più piccoli ed economici. I modelli più potenti dovrebbero essere riservati ai revisori, ai redattori delle regole, alle decisioni architetturali e alle controversie che richiedono un giudizio più ampio.
Mantenere la coda meccanica
Gli script batch dovrebbero determinare cosa è stato completato controllando il filesystem o altri stati deterministici.
Ad esempio, un file sorgente può essere considerato tradotto quando il file di destinazione corrispondente esiste nella directory prevista e ha superato i necessari checkpoint di revisione.
Ricostruire la coda dal disco rende il processo ripristinabile. Se un agente si ferma, la macchina viene riavviata o un batch fallisce, l'orchestratore può ricostruire il lavoro rimanente senza fare affidamento su una memoria di conversazione volatile.
Contrassegnare esplicitamente il lavoro incerto
Quando l'agente realizzatore non può completare la traduzione con sicurezza, dovrebbe lasciare un marcatore ricercabile, ad esempio:
TODO(port): spiegare perché questa parte richiede gestione manuale o elaborazione successiva
La forma specifica del marcatore può variare, ma deve includere la motivazione. Ciò crea una coda strutturata per le fasi di compilazione e correzione.
Utilizzare contesti di revisione indipendenti
L'agente realizzatore non dovrebbe revisionarsi da solo.
Anthropic e Bun hanno adottato la revisione antagonistica in finestre di contesto indipendenti. Il revisore riceve il codice modificato e viene istruito a presumere che l'implementazione contenga difetti.
Due revisori possono controllare indipendentemente lo stesso lotto. Se le conclusioni sono in conflitto, un terzo agente può arbitrare.
Questa separazione riduce la tendenza dell'agente scrittore a difendere le proprie scelte e rende il funzionamento autonomo prolungato più affidabile.
Correggere il generatore, non ogni output
Quando il revisore scopre ripetutamente lo stesso difetto, il manuale delle regole dovrebbe essere aggiornato e i lotti interessati rigenerati.
Rat toppe manualmente centinaia di file generati porta a incongruenze e permette che le modalità di errore originali persistano. Correggere la regola di generazione impedisce che il problema si ripresenti nei lotti successivi.
Fase 4, 5, 6: Compilazione, esecuzione e corrispondenza comportamentale
Le ultime tre fasi condividono lo stesso ciclo di base: produrre guasti oggettivi, classificarli, assegnare un correttore, revisionare la correzione e ripetere.
Fase 4: Compilazione
La compilazione trasforma gli errori a livello di linguaggio in una coda deterministica.
Se la compilazione debba far parte di ogni ciclo di traduzione dipende dai costi.
Il compilatore TypeScript di Mike Krieger può controllare un'unità in pochi secondi, quindi viene eseguito frequentemente durante l'implementazione. La build Rust di Bun richiede più tempo, quindi Jarred Sumner tiene Cargo fuori dal ciclo di traduzione a livello di file e compila lotti più grandi separatamente.
Per build costose, utilizzare un singolo orchestratore o un demone di build. Gli agenti di correzione scrivono patch, consentendo solo al demone di ricostruire. Ciò impedisce a dozzine di agenti di avviare contemporaneamente la stessa operazione costosa.
I guasti del compilatore a livello di sistema meritano attenzione speciale. Migliaia di errori simili potrebbero indicare una regola di dipendenza mancante, una strategia di confini modulari errata o un mapping linguistico problematico, non migliaia di sviste indipendenti.
Fase 5: Eseguire test fumogeni
Una volta che il codice compila, eseguire test minimi che rivelino crash e guasti gravi in fase di runtime.
I risultati dei test fumogeni forniscono un'altra fonte di verità meccanica. Raggruppare i guasti per causa principale anziché assegnare un agente a ogni messaggio di errore senza analisi.
Le categorie utili potrebbero includere:
- Fallimenti di inizializzazione
- Risorse mancanti
- Errori di gestione del percorso
- Differenze di serializzazione
- Difetti del ciclo di vita della memoria
- Comportamenti specifici della piattaforma
- Ipotesi errate sulla concorrenza
- Problemi di interfaccia delle funzioni esterne
I revisori antagonisti dovrebbero controllare le correzioni della causa principale proposte, specialmente quando una singola modifica interessa più file.
Fase 6: Abbinare il comportamento originale
L'ultima fase confronta il nuovo programma con quello originale.
Eseguire suite di test portatili o framework di verifica della parità su entrambe le implementazioni. Qualsiasi differenza inspiegabile dovrebbe essere considerata un difetto di migrazione, a meno che il team non la accetti intenzionalmente come cambiamento di prodotto.
L'agente di correzione può controllare:
- Casi di test falliti
- Implementazione originale
- Implementazione tradotta
- Regole di migrazione che influenzano il codice
- Fallimenti correlati precedenti
Per processi di ricostruzione lunghi, utilizzare un demone di build per elaborare le patch in batch, compilare in una volta sola, eseguire solo i test interessati e restituire i risultati alla coda.
Quando lo stesso modello di fallimento appare in più test, la misura correttiva dovrebbe essere spostata a monte. Aggiornare il manuale delle regole e rigenerare i file sotto la regola errata.
Cosa fare in assenza di una suite di test portabile
La mancanza di una suite di test non significa che la migrazione sia impossibile.
L'applicazione originale può essere utilizzata come implementazione di riferimento per costruire un framework di verifica della parità comportamentale attorno a scenari utente reali.
Il flusso di lavoro di Mike Krieger esegue sette scenari sia per la versione Python che per quella TypeScript, confronta i risultati e assegna ogni fallimento a un ciclo di correzione dedicato. Successivamente, Claude ha progettato test end-to-end aggiuntivi, eseguiti per quattro notti consecutive.
Anche se il team deve costruire un nuovo meccanismo di arbitrato attorno al codice originale, il codice originale rimane l'unico punto di riferimento.
Lezioni pratiche applicabili a progetti diversi
Anthropic avverte di non considerare il proprio flusso di lavoro come un modello universale. Ogni codebase ha costi di build, semantiche linguistiche, qualità dei test, vincoli di piattaforma e compromessi accettabili diversi.
Tuttavia, le seguenti pratiche sono coerenti in più progetti.
Concentrarsi sui modelli, non sui fallimenti individuali
I singoli casi di fallimento appartengono al ciclo di correzione.
L'attenzione umana dovrebbe concentrarsi su difetti ricorrenti, regole mancanti, confini di compiti irragionevoli, anelli di verifica deboli e colli di bottiglia nel sistema di orchestrazione.
Adottare la revisione antagonistica
I revisori dovrebbero cercare attivamente di dimostrare che il codice è sbagliato.
Ciò non significa giudizi vaghi o pessimistici. Le conclusioni della revisione dovrebbero indicare difetti specifici, regole violate, ipotesi non valide o mancata corrispondenza comportamentale.
Automatizzare la verifica
Compilatori, casi di test, script deterministici, benchmark e differenze di output dovrebbero essere i criteri di accettazione dei risultati.
Le opinioni dei modelli sono utili per la ricerca e la revisione, ma non dovrebbero sostituire la verifica oggettiva – quando questa è possibile.
Evitare di usare il modello più potente ovunque
Il lavoro di traduzione su larga scala è spesso ripetitivo e può essere affidato a modelli più piccoli.
I modelli più potenti dovrebbero essere utilizzati per:
- Definire le regole
- Revisionare l'architettura
- Scoprire difetti sistemici
- Risolvere divergenze di revisione
- Progettare schemi di verifica
- Gestire casi limite difficili
Ciò riduce i costi dei token senza rimuovere il forte ragionamento dalle decisioni ad alto rischio.
Investire lavoro umano a monte
Il manuale delle regole, il grafico delle dipendenze, la strategia di verifica e i test di stress richiedono la partecipazione umana più attenta.
Una volta che queste basi sono solide, il resto del lavoro diventa un processo di gestione della coda. Basi deboli rendono ogni fase successiva più costosa.
Garantire che il flusso di lavoro sia ripristinabile
Il processo di migrazione dovrebbe essere in grado di riprendersi da un'interruzione senza dover ricostruire lo stato dalla cronologia della chat.
Memorizzare lo stato in file, commit, elenchi, database o altri artefatti deterministici."Completato" dovrebbe avere un significato leggibile dalla macchina.
Separare le operazioni condivise costose
Compilazione, test di integrazione, creazione di pacchetti e benchmark completi possono diventare colli di bottiglia.
Eseguire queste operazioni tramite un servizio o demone controllato, in modo che gli agenti paralleli non sprechino risorse o danneggino lo stato condiviso.
Risultati della migrazione a Rust di Bun
La versione Rust di Bun è in produzione, sebbene permangano compromessi ingegneristici nei risultati.
Anthropic riporta che circa il 4% del codice Rust rimane all'interno di blocchi unsafe, principalmente operazioni brevi sui puntatori ai confini con C e C++. Rust non ha eliminato tutti i problemi di basso livello, ma li ha maggiormente confinati in aree esplicite.
I miglioramenti riportati includono:
| Metrica di misura | Risultato |
|---|
| Utilizzo memoria per 2000 build ripetute | Da 6745 MB a 609 MB |
| Dimensione binario su Linux e Windows | Ridotta del 19% |
| Prestazioni su carichi di lavoro reali selezionati | Migliorate del 2%–5% |
| Perdite di memoria rilevabili | Risolte |
| Regressioni segnalate da Anthropic dopo l'unione | 19, successivamente risolte |
Questi risultati sono più importanti del semplice numero di righe di codice originali. Una migrazione di successo non si misura dalla velocità con cui un agente genera codice, ma dalla compatibilità, manutenibilità, miglioramenti operativi e dalla capacità di sviluppare ulteriormente il prodotto dopo l'unione.
Cosa valutare prima di avviare il team
Prima di avviare una migrazione su larga scala assistita dall'IA, rispondere alle seguenti domande.
L'implementazione sorgente è un punto di riferimento stabile?
Se il sistema originale è in rapida evoluzione, sarà difficile misurare la coerenza. Valutare di congelare interfacce selezionate o di migrare prioritariamente moduli stabili.
È possibile misurare il successo in modo meccanico?
Definire controlli del compilatore, test, scenari, benchmark e confronti di output che determinano il completamento.
Obiettivi vaghi come "renderne il comportamento coerente" non sono sufficienti.
La migrazione conserva la struttura o riprogetta?
Un porting diretto è più facile da confrontare e parallelizzare. La riprogettazione può produrre un'architettura migliore, ma introduce più giudizi e richiede revisioni progettuali più rigorose.
Qual è la risorsa più costosa?
Valutare i seguenti costi:
- Chiamate al modello
- Compilazione
- Esecuzione dei test
- Concorrenza CI
- Archiviazione repository
- Esecuzione integrale dell'integrazione
- Revisione manuale
Progettare l'orchestratore attorno alla risorsa condivisa più costosa.
Quali operazioni richiedono approvazione umana?
Definire i seguenti confini:
- Comandi Git distruttivi
- Modifiche alle dipendenze
- Variazioni architetturali
- Codice sensibile alla sicurezza
- Credenziali di produzione
- Operazioni di rilascio
- Modifiche alle API pubbliche
Nel flusso di lavoro di Bun, gli agenti interferivano tra loro tramite comandi come git stash e git reset. Le regole di orchestrazione sono state aggiornate per vietare operazioni non sicure sul repository condiviso e limitare gli agenti a commit controllati a livello di file.
Qual è la strategia di rollback?
Fino a quando non ci sono prove a sostegno dell'unione, la migrazione dovrebbe rimanere scartabile.
Utilizzare branch isolati, build riproducibili, checkpoint e processi chiari per abbandonare o rigenerare il lavoro in caso di regole errate.
Domande frequenti
Cos'è la migrazione del codice assistita dall'IA?
La migrazione del codice assistita dall'IA utilizza agenti di codifica che, sotto un flusso di lavoro controllato, eseguono traduzione, revisione, compilazione, test e correzione del codebase. Il modello non sostituisce la fase di verifica; compilatore, test, controlli di coerenza e regole definite dall'uomo rimangono l'autorità.
Claude Code ha davvero riscritto Bun da Zig a Rust?
Jarred Sumner ha completato il porting in Rust utilizzando il flusso di lavoro dinamico di Claude Code, e la relativa pull request GitHub è stata unita a maggio 2026. L'account ufficiale di Bun ha dichiarato che il lavoro ha richiesto circa 11 giorni, basandosi su implementazioni parallele, revisioni antagoniste e la suite di test indipendente dal linguaggio già esistente nel progetto.
Quante righe di codice ha coinvolto la migrazione di Bun?
La pull request unita mostra oltre un milione di nuove righe di codice, insieme a righe cancellate e modificate. Il solo numero di righe non misura la qualità, quindi gli indicatori più importanti sono i risultati della compilazione, i test multipiattaforma, il comportamento, l'occupazione di memoria, la dimensione del binario e la gestione delle regressioni dopo l'unione.
Quanto è costata la migrazione AI di Bun?
Sulla base di 5,9 miliardi di token di input non memorizzati nella cache e 690 milioni di token di output, Anthropic stima un costo API di circa 165.000 dollari. Il costo effettivo per un'organizzazione può variare a seconda degli accordi sui prezzi, dell'infrastruttura interna, delle ore di lavoro umano, dell'uso della CI e delle correzioni post-unione.
Cos'è un manuale delle regole di migrazione?
Un manuale delle regole di migrazione è un insieme di politiche leggibili dalla macchina o dagli agenti, che descrivono come i pattern del linguaggio sorgente si mappano all'implementazione target. Copre tipi, proprietà, errori, interfacce, denominazioni, casi non supportati, decisioni architetturali e altre regole che gli agenti di implementazione devono seguire in modo coerente.
Perché utilizzare un revisore antagonista?
L'agente di implementazione ha contesto e inerzia che possono indurlo ad accettare le proprie soluzioni. Il revisore antagonista lavora in un contesto indipendente, con l'istruzione di cercare difetti, violazioni delle regole e differenze comportamentali, anziché aiutare a unire il codice.
Questo approccio funziona se non esiste una suite di test esistente?
Possibile, ma il team deve stabilire un altro arbitro oggettivo. Una piattaforma di test di coerenza può eseguire scenari reali su entrambe le implementazioni e confrontare gli output, mentre nuovi test end-to-end possono esporre errori non rilevati dai controlli di traduzione statici.
Ogni codebase legacy è ora adatto per la migrazione AI?
Non necessariamente. La migrazione richiede ancora vantaggi misurabili, un'implementazione di riferimento stabile, una validazione oggettiva, un budget adeguato e un piano di rollback accettabile. I sistemi con test deboli, comportamento non documentato, requisiti in rapida evoluzione o vincoli di sicurezza critici potrebbero richiedere una preparazione preliminare significativa o non essere affatto fattibili con le attuali capacità dell'IA.
Lavoro preparatorio necessario prima che gli agenti possano aiutare in modo responsabile.
Strumenti correlati
- Claude Code: lo strumento di codifica intelligente di Anthropic per comprendere i repository di codice, modificare file, eseguire comandi e coordinare lo sviluppo.
- Kit di migrazione del codice Anthropic: messaggi, modelli e script ufficiali per costruire flussi di lavoro di migrazione linguistica.
- Plugin di modernizzazione Claude Code: plugin ufficiali focalizzati su aggiornamenti di framework e modernizzazione di sistemi legacy (non porting linguistico completo).
- Bun: il set di strumenti JavaScript e TypeScript utilizzato nel case study di Anthropic per la migrazione da Zig a Rust di un milione di righe di codice.
- Rust: il linguaggio di sistema memory-safe scelto per la nuova implementazione di Bun.
- Zig: il linguaggio di programmazione di sistema utilizzato da Bun prima della migrazione a Rust.
- TypeScript: il linguaggio JavaScript tipizzato utilizzato nell'esempio di migrazione Python di Anthropic.
Link correlati
- Guida di Anthropic alla migrazione del codice su larga scala: la metodologia ufficiale in sei passi e due case study di migrazione Anthropic.
- Riscrittura di Bun in Rust: Spiegazione tecnica dettagliata di Jarred Sumner su motivazioni, ciclo di orchestrazione, processo di revisione e risultati della migrazione.
- Pull request per la riscrittura di Bun in Rust: Pull request pubblica unita contenente la migrazione di massa a Rust.
- Kit di migrazione del codice da utilizzare con Claude Code: Kit di avvio generico distillato dal processo di migrazione.
- Introduzione ai flussi di lavoro dinamici: Spiegazione di Anthropic dei flussi di lavoro multi-agente di lunga durata e adattivi in Claude Code.
- Documentazione di Claude Code: Documentazione ufficiale su installazione, flussi di lavoro, configurazione e utilizzo.
- Best practice di Claude Code: Guida pratica su contesto del repository, sessioni parallele, validazione e flussi di lavoro degli agenti.
Riepilogo
Le recenti pratiche di migrazione di Anthropic dimostrano che i progetti di trasferimento linguistico possono essere riorganizzati attorno a flussi di lavoro basati su agenti intelligenti, invece di affidarsi a riscritture manuali singole e prolungate. La migrazione di Bun da Zig a Rust e il progetto di Anthropic da Python a TypeScript si basano su implementazione parallela, revisione antagonistica, verifica deterministica e rigenerazione iterativa.
La parte riutilizzabile è il processo: costruire un valutatore, definire regole, mappare le dipendenze, sottoporre i metodi a stress test, tradurre in lotti recuperabili, compilare, eseguire e confrontare i comportamenti. Quando lo stesso difetto si ripresenta, si corregge la regola o il flusso di lavoro che lo genera, anziché riparare manualmente ogni singolo output.
Questo approccio richiede comunque un budget considerevole, test robusti, permessi controllati e un giudizio umano a livello architetturale. Riduce i costi di migrazione, ma non elimina il lavoro ingegneristico.
Responsabilità.
Il punto centrale è semplice: una migrazione AI affidabile deriva da cicli di produzione verificabili, non da un singolo prompt che chiede al modello di riscrivere l'intera base di codice.