Como a Anthropic está realizando migrações de código em larga escala com o Claude Code

Introdução

Alterar a linguagem principal de uma base de código madura em produção costumava ser o tipo de projeto que as equipes adiavam por anos. Esse trabalho é caro, arriscado e difícil de estimar. Uma migração poderia consumir vários trimestres de engenharia, com duas implementações divergindo gradualmente e, no final, alcançando apenas uma consistência comportamental incompleta.

Um projeto interno recente da Anthropic mostra que isso está começando a mudar.

Em julho de 2026, a Anthropic publicou um relatório prático detalhando como seus desenvolvedores usaram Claude Code, Claude Fable 5, Claude Opus 4.8 e um fluxo de trabalho multiagente dinâmico para migrar dez pacotes de código em cerca de um mês. Esses pacotes variavam de dezenas de milhares a centenas de milhares de linhas de código.

Dois casos se destacaram particularmente:

• Jarred Sumner, cofundador da Bun, usou o Claude Code para migrar a Bun de Zig para Rust, gerando mais de um milhão de linhas de código em menos de duas semanas.
• Mike Krieger, co-diretor da Anthropic Labs, converteu uma base de código Python em aproximadamente 165 mil linhas de TypeScript em um fim de semana.

O insight importante não é que modelos de IA podem traduzir arquivos rapidamente, mas que um sistema de migração bem projetado pode gerar, revisar, testar, rejeitar e regenerar código repetidamente com intervenção humana mínima.

A Anthropic resume sua filosofia assim: o trabalho principal do desenvolvedor não é corrigir manualmente cada erro gerado, mas sim melhorar o processo que continuamente produz esses erros.

Duas migrações de código que mudam o cálculo de custos

Bun: Migração de mais de um milhão de linhas de Zig para Rust

Bun é um toolkit JavaScript e TypeScript completo, incluindo runtime, gerenciador de pacotes, bundler, executor de testes e outras ferramentas de desenvolvimento. Sua implementação original dependia fortemente de Zig e integrava-se com uma grande quantidade de código C e C++.

Jarred Sumner usou cerca de 50 fluxos de trabalho dinâmicos do Claude Code em 11 dias para concluir a migração para Rust. O pull request mesclado continha mais de um milhão de linhas de código novo e milhares de commits.

Antes da mesclagem, o conjunto de testes de integração contínua existente da Bun passou em todas as plataformas suportadas. A Anthropic relatou posteriormente 19 regressões após a mesclagem, todas corrigidas em seguida.

Esta migração não foi um redesign do zero. O objetivo era manter a arquitetura e o comportamento existentes da Bun enquanto substituía a linguagem de implementação. Isso reduziu as variáveis em jogo: o projeto poderia focar em semântica de linguagem, ownership, segurança de memória e compatibilidade, em vez de reconstruir o produto do zero.

O relatório oficial da Bun explica por que Rust era atraente. Muitos problemas recorrentes de estabilidade envolviam gerenciamento de ciclo de vida, caminhos de limpeza esquecidos, uso após liberação, condições de corrida e risco de double free. Em Rust seguro, muitos desses problemas se tornam erros de compilação, em vez de problemas descobertos apenas através de falhas em produção, fuzzing ou revisão manual.

Migração de Python para TypeScript em um fim de semana

O projeto de Mike Krieger seguiu um caminho diferente. Em vez de preservar ao máximo a estrutura de arquivos original, esta migração envolveu mais redesign arquitetural.

O resultado foi a geração de aproximadamente 165.000 linhas de código TypeScript em um fim de semana. O processo supostamente usou:

• Centenas de agentes.
• Oito estágios.
• Três rodadas de revisão adversarial.
• Um framework de testes de consistência para comparar a saída de cada comando com a implementação Python.

A justificativa de negócios era clara. Esta ferramenta interna baseada em Python era distribuída como um único binário, mas gerar esse binário levava cerca de oito minutos por plataforma, totalizando aproximadamente 30 minutos para toda a matriz de lançamento.

Após a migração, a compilação levou cerca de dois segundos, a velocidade de inicialização aumentou seis vezes e a equipe pôde eliminar um pipeline de deploy separado.

Quando vale a pena considerar uma migração de linguagem

Migrações de linguagem ainda exigem uma verdadeira justificativa de engenharia ou negócios. Geração de código mais rápida não significa que cada reescrita é justificada.

As equipes geralmente reconsideram a escolha da linguagem quando o ambiente desde a criação do sistema mudou. Gatilhos típicos incluem:

1. Compromissos conhecidos tornaram-se problemas operacionais recorrentes.
2. Linguagens ou ecossistemas mais recentes agora oferecem melhor suporte de ferramentas.
3. O ecossistema original está encolhendo ou é difícil recrutar talentos para ele.
4. Requisitos de segurança ou segurança de memória mudaram.
5. Desempenho de construção, implantação ou tempo de execução tornou-se um gargalo.
6. Manter a compatibilidade exige workarounds cada vez mais caros.

O uso inicial de Zig pela Bun fazia sentido. Para um fundador construindo sozinho um runtime muito amplo antes do surgimento de agentes de codificação contemporâneos, a linguagem fornecia controle de baixo nível que ajudou Jarred Sumner a avançar rapidamente.

Anos depois, Bun tornou-se uma ferramenta de produção amplamente usada com uma superfície de manutenção muito maior. O custo de bugs recorrentes relacionados à memória aumentou, e o Claude Code tornou a portabilidade mecânica viável o suficiente para ser testada.

Portanto, a decisão não foi "Zig é ruim e Rust é bom", mas sim que a escala atual da Bun, suas necessidades operacionais e as ferramentas disponíveis mudaram as compensações.

Migração mais rápida, mas não gratuita

Migrações de linguagem assistidas por IA ainda podem ser caras.

A Anthropic relatou que o projeto Bun consumiu aproximadamente:

Categoria de uso	Quantidade reportada
Tokens de entrada não armazenados em cache	5,9 bilhões
Tokens de saída	690 milhões
Equivalente estimado de preço de API	Cerca de US$ 165.000

A parte principal da migração Python para TypeScript de Mike Krieger usou cerca de 27 milhões de tokens.

Esses números são muito menores que o custo de engenharia de migrações tradicionais de vários anos, mas não são insignificantes. As equipes também devem considerar:

• Supervisão humana.
• Sobrecarga computacional e de API.
• Infraestrutura de teste.
• Capacidade de CI.
• Máquinas de construção.
• Revisão e correção pós-mesclagem.
• Custo de oportunidade durante a migração.
• Manutenção de longo prazo da linguagem alvo.

A redução de custos torna mais projetos financeiramente viáveis, mas não elimina a necessidade de um business case.

Por que grandes migrações são tão adequadas para agentes de IA

Grandes migrações de linguagem possuem várias características que as tornam particularmente adequadas para trabalho com agentes de codificação colaborativos.

Trabalho paralelizável

Migrações geralmente envolvem centenas ou milhares de arquivos, módulos, pacotes ou bibliotecas, que podem ser processados independentemente, desde que suas dependências sejam compreendidas.

Agentes podem traduzir unidades independentes em paralelo, em vez de esperar por um único fluxo de implementação central. O desafio muda de velocidade de digitação para orquestração, consistência e validação.

Código antigo como especificação detalhada

Muitas tarefas de software começam com requisitos incompletos. Migrações de linguagem começam com algo muito mais poderoso: a implementação original.

O código-fonte existente define fluxo de controle, estruturas de dados, casos limite, comportamento de erros, APIs públicas e tratamento específico de plataforma. Quando as regras de migração não são claras, os agentes podem consultar o original a qualquer momento.

Testes fornecem um árbitro objetivo

Agentes têm melhor desempenho quando sucesso e falha podem ser verificados mecanicamente.

Compiladores, suítes de teste, scripts de consistência, benchmarks ou comparação de saída determinística fornecem a única fonte de verdade para o workflow. O sistema não precisa perguntar a revisores se a nova implementação "parece correta"; ele repetidamente compara o comportamento com a implementação original.

Falhas se convertem automaticamente em tarefas

Erros de compilador, falhas, testes quebrados e diferenças de saída descrevem naturalmente o trabalho restante.

O sistema de migração não precisa que humanos escrevam listas de tarefas item por item.

Cada item de verificação com falha pode ser categorizado e atribuído a um agente de correção.

Erros repetidos podem ser corrigidos upstream

Quando o mesmo problema aparece em vários arquivos, corrigir manualmente um por um não é a abordagem correta.

A melhor solução é atualizar a regra de migração que causou o erro e, em seguida, regenerar apenas as unidades afetadas. Isso transforma um defeito encontrado em uma melhoria permanente no processo.

Pré-requisito: construir um avaliador confiável

Antes de traduzir o código de produção, é necessário criar um sistema de validação que possa avaliar a implementação antiga e a nova em condições equivalentes.

Sem um avaliador confiável, o projeto não terá uma definição de conclusão confiável.

Suítes de teste escritas na linguagem de origem podem depender de funções privadas, classes internas ou detalhes de implementação que não existem na linguagem de destino. Esses testes nem sempre podem ser migrados diretamente.

A Anthropic sugere três etapas para preparar o sistema avaliador.

1. Classificar os testes existentes

Separe os testes que expressam comportamento externo daqueles que dependem de detalhes internos de implementação.

Testes externos geralmente envolvem comportamento de linha de comando, APIs públicas, arquivos, rede, saída observável ou cenários completos de aplicação. Esses conteúdos são mais portáveis entre diferentes linguagens.

2. Reescrever testes para portabilidade

Converta testes orientados a comportamento em asserções que possam ser executadas em ambas as versões.

Use revisores adversariais independentes para garantir que os testes reescritos não sejam mais fracos que a versão original. Testes que passam com mais facilidade podem ocultar problemas de compatibilidade.

3. Validar o próprio sistema de julgamento

Execute o sistema de julgamento na implementação original e confirme que ele passa.

Em seguida, quebre o programa intencionalmente e confirme que o sistema de julgamento falha. Se um sistema de validação não consegue detectar defeitos conhecidos, ele não está pronto para supervisionar a migração.

Mike Krieger não construiu do zero uma suíte de testes completamente portável. Sua equipe criou um framework de testes de consistência cobrindo sete cenários reais e tratou qualquer diferença entre Python e TypeScript como um defeito.

Fluxo de migração de código Claude em seis etapas

Primeira etapa: criar manual de regras, gráfico de dependências e lista de lacunas

A primeira etapa estabelece a base que todos os agentes subsequentes utilizarão.

Primeiro, construa o manual de regras

O manual de regras descreve como a linguagem de origem deve ser mapeada para a linguagem de destino.

Seu formato depende da estratégia de migração.

Para migrações que preservam a estrutura, o manual de regras pode conter:

• Mapeamento de tipos.
• Mapeamento de tratamento de erros.
• Regras de propriedade.
• Convenções de nomenclatura.
• Alternativas para a biblioteca padrão.
• Padrões de interface de funções externas.
• Regras para operações assíncronas.
• Instruções para construções não suportadas.

Para redesenho, o manual de regras se aproxima mais de um documento de arquitetura. Ele define novos limites de componentes, interfaces, contratos de dados e decisões de design que os agentes de implementação devem seguir.

A ordem é importante. O manual de regras deve ser escrito antes da lista de lacunas, pois a lista de lacunas registra tudo o que as regras padrão não conseguem tratar com segurança.

Mapear dependências

O trabalho paralelo só é seguro quando o fluxo de trabalho entende quais unidades dependem umas das outras.

O gráfico de dependências ajuda a determinar:

• Quais módulos devem ser migrados primeiro.
• Quais arquivos pertencem ao mesmo lote.
• Quais interfaces devem ser estabilizadas antes que o trabalho downstream comece.
• Quais ciclos precisam de tratamento especial.
• Quais agentes paralelos podem entrar em conflito.

Algumas linguagens expõem informações de dependência por meio de manifestos de pacote ou metadados de módulo. Sistemas mais antigos em C, C++ e Python podem exigir scripts de análise determinística para descobrir o gráfico de dependências.

Claude Code pode ajudar a criar e executar esse script, mas o gráfico gerado deve ser produzido por meios mecânicos, não apenas por suposições baseadas na saída do modelo.

Registrar lacunas de linguagem e arquitetura

A lista de lacunas captura diferenças que não podem ser tratadas por tradução direta.

Para uma migração de Zig para Rust, lacunas importantes incluem propriedade e ciclo de vida da memória. Zig permite que algumas responsabilidades de limpeza sejam

comunicadas por convenção ou anotações, enquanto Rust exige que as restrições de propriedade sejam expressas no sistema de tipos.

Para um trabalho de migração de Python para TypeScript, a definição de interface é uma lacuna importante. Python geralmente aceita objetos com base no comportamento em tempo de execução, enquanto TypeScript exige contratos explícitos antes que o código possa ser compilado com segurança.

A lista deve ser tratada como um artefato atualizado dinamicamente. Novas lacunas surgem continuamente durante os processos de tradução, compilação e teste de conformidade.

Segunda etapa: testar as regras sob estresse por meio de mini-migrações únicas

Não aplique imediatamente o novo manual de regras a milhares de arquivos.

Primeiro, realize uma migração pequena e, em seguida, descarte deliberadamente os resultados.

Para o Bun, o teste envolveu um pequeno número de arquivos:

1. Um agente traduziu arquivos com base no manual de regras.
2. Outro agente traduziu arquivos comparáveis como faria um engenheiro Rust experiente.
3. Um terceiro agente comparou os resultados e propôs regras mais fortes.
4. Revisores adversariais procuraram problemas comportamentais ou estruturais.

Antes de aplicar a todos os 1.448 arquivos Zig, esse trabalho expôs dois problemas graves.

Migrações que preservam a estrutura tornam essa comparação relativamente fácil, pois duas implementações do mesmo arquivo podem ser revisadas lado a lado.

Para redesenho, o teste de estresse deve ser direcionado ao documento de arquitetura. Agentes adversariais podem atacar suas suposições e, em seguida, uma execução ponta a ponta única expõe interfaces ausentes e ordens irrealistas.

O objetivo é melhorar o manual de regras, não acumular código de produção. Depois de capturar as fraquezas, descarte os arquivos gerados.

Terceira etapa: traduzir a base de código completa

Depois que as regras passam pelo teste de estresse, o trabalho de tradução pode ser expandido para todo o repositório.

com/cms-assets/image/2026/07/26354d74-9a83-4821-b425-a17b95bb4e0e-677c6dd7-8531-47f9-93ce-bf7d7df38679.jpeg)

A Anthropic descreve um ciclo repetitivo com três papéis:

1. Implementador gera o código traduzido.
2. Revisor adversário encontra falhas e violações de regras.
3. Corretor aplica o feedback de revisão aceito.

O trabalho de implementação geralmente pode usar modelos menores e mais baratos. Os modelos mais fortes devem ser reservados para revisores, redatores de regras, decisões de arquitetura e disputas que exigem julgamento mais amplo.

Manter a fila mecânica

Scripts em lote devem decidir o que está concluído verificando o sistema de arquivos ou outro estado determinístico.

Por exemplo, um arquivo fonte pode ser considerado traduzido quando o arquivo de destino correspondente existe no diretório esperado e passou pelos portões de revisão necessários.

Reconstruir a fila a partir do disco torna o processo recuperável. Se um agente parar, a máquina reiniciar ou um lote falhar, o orquestrador pode reconstruir o trabalho restante sem depender da memória volátil da conversa.

Marcar explicitamente o trabalho incerto

Quando o agente implementador não consegue concluir a tradução com confiança, deve deixar uma marcação pesquisável, como:

TODO(port): Explicar por que esta parte precisa de tratamento manual ou processamento posterior

A forma específica da marcação pode variar, mas deve incluir o motivo. Isso cria uma fila estruturada para as fases de compilação e correção.

Usar contextos de revisão independentes

O agente implementador não deve revisar a si mesmo.

A Anthropic e a Bun adotaram revisão adversária em janelas de contexto independentes. O revisor recebe o código alterado e é instruído a assumir que a implementação contém falhas.

Dois revisores podem verificar o mesmo lote de forma independente. Se houver conflito de conclusões, um terceiro agente pode julgar.

Essa separação reduz a tendência do agente de escrita de defender suas próprias escolhas e torna a execução autônoma de longa duração mais confiável.

Corrigir o gerador, não cada saída

Quando um revisor encontra repetidamente o mesmo defeito, o manual de regras deve ser atualizado e os lotes afetados regenerados.

Corrigir manualmente centenas de arquivos gerados leva a inconsistências e permite que o modo de falha original persista. Corrigir a regra de geração impede que o problema se repita em lotes subsequentes.

Etapas 4, 5 e 6: Compilar, Executar e Corresponder Comportamento

As três fases finais compartilham o mesmo ciclo básico: produzir falhas objetivas, classificar, atribuir um corretor, revisar a correção e repetir.

Etapa 4: Compilar

A compilação transforma erros em nível de linguagem em uma fila determinística.

Se a compilação faz parte de cada ciclo de tradução depende do custo.

O compilador TypeScript de Mike Krieger verifica uma unidade em segundos, portanto é executado com frequência durante a implementação. A construção Rust da Bun leva mais tempo, então Jarred Sumner manteve o Cargo fora do ciclo de tradução em nível de arquivo e compilou lotes maiores separadamente.

Para construções caras, use um único orquestrador ou um daemon de construção. O agente de correção escreve patches, permitindo que apenas o daemon reconstrua. Isso evita que dezenas de agentes iniciem a mesma operação cara simultaneamente.

Falhas do compilador em nível de sistema merecem atenção especial. Milhares de erros semelhantes podem indicar uma regra de dependência ausente, uma estratégia de limite de módulo incorreta ou um mapeamento de linguagem problemático, em vez de milhares de descuidos não relacionados.

Etapa 5: Executar testes de fumaça

Após a compilação do código, execute testes mínimos que exponham travamentos e falhas graves de tempo de execução.

Os resultados dos testes de fumaça fornecem outra fonte de verdade mecânica. Agrupe falhas por causa raiz, em vez de atribuir um agente para cada mensagem de erro sem análise.

Categorias úteis podem incluir:

• Falhas de inicialização
• Recursos ausentes
• Erros de manipulação de caminho
• Diferenças de serialização
• Defeitos no ciclo de vida da memória
• Comportamento específico de plataforma
• Suposições incorretas de concorrência
• Problemas de interface de função externa

Os revisores adversários devem verificar as correções de causa raiz propostas, especialmente quando uma única alteração afeta vários arquivos.

Etapa 6: Corresponder o comportamento original

A fase final precisa comparar o novo programa com o original.

Execute conjuntos de testes portáteis ou estruturas de validação de paridade em ambas as implementações. Qualquer diferença inexplicável deve ser tratada como um defeito de migração, a menos que a equipe a aceite intencionalmente como uma mudança de produto.

O agente de correção pode verificar:

• Casos de teste com falha
• A implementação original
• A implementação traduzida
• Regras de migração que afetam o código
• Casos de falha anteriores relacionados

Para processos de reconstrução demorados, use um daemon de construção para processar patches em lote, compilar de uma só vez, executar apenas os testes afetados e retornar os resultados à fila.

Quando o mesmo padrão de falha aparece em vários testes, a medida corretiva deve ser adiantada. Atualize o manual de regras e regenere os arquivos sob regras incorretas.

Abordagem para falta de conjunto de testes portátil

A falta de um conjunto de testes não significa que a migração não possa ser concluída.

O aplicativo original pode ser usado como implementação de referência para construir uma estrutura de validação de paridade de comportamento em torno de cenários reais de usuário.

O fluxo de trabalho de Mike Krieger executou sete cenários nas versões Python e TypeScript, comparou as saídas e atribuiu cada caso de falha a um ciclo de correção dedicado. Depois, Claude projetou testes ponta a ponta adicionais, executando testes por quatro noites consecutivas.

Mesmo que a equipe precise construir um novo mecanismo de arbitragem em torno do código original, o código original continua sendo o único padrão de referência.

Lições práticas aplicáveis entre projetos

A Anthropic alerta para não tratar seu fluxo como um modelo universal. Cada base de código tem diferentes custos de construção, semânticas de linguagem, qualidade de teste, restrições de plataforma e compensações aceitáveis.

No entanto, as práticas a seguir são consistentes em vários projetos.

Focar em padrões, não em falhas individuais

Falhas individuais pertencem ao ciclo de correção.

O esforço humano deve se concentrar em defeitos recorrentes, regras ausentes, limites de tarefa irracionais, elos de verificação fracos e gargalos no sistema de orquestração.

Adotar revisão adversária

O revisor deve tentar ativamente provar que o código está errado.

Isso não significa ambiguidade ou julgamento pessimista. A conclusão da revisão deve apontar defeitos específicos, regras violadas, suposições inválidas ou incompatibilidades de comportamento.

Automatizar a verificação

Compiladores, casos de teste, scripts determinísticos, benchmarks e diffs de saída devem se tornar critérios de aceitação de resultados.

As opiniões do modelo são valiosas para pesquisa e revisão, mas não devem substituir a verificação objetiva—sempre que a verificação objetiva for viável.

Evitar usar o modelo mais forte em todos os lugares

O trabalho de tradução em larga escala geralmente é repetitivo e pode ser tratado por modelos menores.

Os modelos mais fortes devem ser usados para:

• Definir regras
• Revisar arquitetura
• Descobrir defeitos sistêmicos
• Resolver divergências de revisão
• Projetar esquemas de verificação
• Lidar com casos de borda difíceis

Isso reduz o custo do token sem remover o raciocínio forte das decisões de maior risco.

Investir esforço humano antecipadamente

O manual de regras, o gráfico de dependências, a estratégia de validação e os testes de estresse exigem a participação humana mais cuidadosa.

Uma vez que essas bases estejam sólidas, o restante do trabalho se torna processamento de fila. Bases fracas tornam cada etapa subsequente mais cara.

Garantir que o fluxo de trabalho possa ser retomado após interrupção

O processo de migração deve ser capaz de se recuperar de interrupções sem reconstruir o estado por meio do histórico do chat.

Armazene o progresso em arquivos, commits, listas, bancos de dados ou outros artefatos determinísticos. "Concluído" deve ter um significado legível por máquina.

Separar operações compartilhadas caras

Compilação, testes de integração, criação de pacotes e benchmarks completos podem se tornar gargalos.

Execute essas operações por meio de um serviço ou daemon controlado para que agentes paralelos não desperdicem recursos ou corrompam o estado compartilhado.

Resultados da migração Rust da Bun

A versão Rust da Bun já está em produção, embora ainda existam compensações de engenharia nos resultados.

A Anthropic relata que cerca de 4% do código Rust ainda reside em blocos unsafe, principalmente envolvendo operações curtas de ponteiro nas fronteiras com C e C++. O Rust não eliminou todos os problemas de baixo nível, mas os restringiu mais a regiões explícitas.

As melhorias relatadas incluem:

Métrica	Resultado

| Uso de memória em 2000 reconstruções repetidas | Reduzido de 6745 MB para 609 MB |
| Tamanho do binário no Linux e Windows | Reduzido em 19% |
| Desempenho em cargas de trabalho reais selecionadas | Melhoria de 2% a 5% |
| Vazamentos de memória detectáveis | Corrigidos |
| Problemas de regressão relatados pela Anthropic | 19, posteriormente corrigidos |

Esses resultados são mais importantes do que a contagem bruta de linhas de código. Uma migração bem-sucedida não é medida pela velocidade com que o agente gera código, mas pela compatibilidade, capacidade de manutenção, melhorias operacionais e pela capacidade de continuar desenvolvendo o produto após a migração.

O que a equipe deve avaliar antes de iniciar

Antes de iniciar uma migração assistida por IA em larga escala, responda às seguintes perguntas.

A implementação de origem é um ponto de referência estável?

Se o sistema original estiver mudando rapidamente, será difícil medir a consistência. Considere congelar interfaces selecionadas ou priorizar a migração de módulos estáveis.

É possível medir o sucesso de forma mecânica?

Defina verificações de compilador, testes, cenários, benchmarks e comparações de saída que determinem a conclusão.

Metas vagas como "fazê-lo se comportar de forma consistente" não são suficientes.

A migração mantém a estrutura ou redesenha?

A portabilidade direta facilita a comparação e a paralelização. Redesenhar pode gerar uma arquitetura melhor, mas envolve mais julgamento e exige revisões de design mais rigorosas.

Qual é o gargalo mais caro?

Avalie os seguintes custos:

• Chamadas de modelo
• Compilação
• Execução de testes
• Concorrência de CI
• Armazenamento do repositório
• Execução da integração completa
• Revisão humana

Projete o orquestrador em torno do recurso compartilhado mais caro.

Quais operações exigem aprovação humana?

Defina os seguintes limites:

• Comandos Git destrutivos
• Alterações de dependências
• Mudanças de arquitetura
• Código sensível à segurança
• Credenciais de ambiente de produção
• Operações de lançamento
• Alterações em APIs públicas

O fluxo de trabalho do Bun encontrou agentes interferindo uns com os outros através de comandos como git stash e git reset. As regras de orquestração foram atualizadas para proibir operações inseguras no repositório compartilhado e limitar os agentes a commits controlados em nível de arquivo.

Qual é a estratégia de reversão?

Até que haja evidências que apoiem a mesclagem, a migração deve permanecer descartável.

Use branches isolados, builds reproduzíveis, pontos de verificação e processos claros para abandonar ou regenerar o trabalho quando as regras estiverem erradas.

Perguntas frequentes

O que é migração de código assistida por IA?

A migração de código assistida por IA usa agentes de codificação, sob um fluxo de trabalho controlado, para realizar a tradução, revisão, compilação, teste e correção da base de código. O modelo não substitui a validação; compiladores, testes, verificações de consistência e regras definidas por humanos continuam sendo a autoridade final.

O Claude Code realmente reescreveu o Bun de Zig para Rust?

Jarred Sumner concluiu a portabilidade para Rust usando o fluxo de trabalho dinâmico do Claude Code, e o pull request do GitHub foi mesclado em maio de 2026. A conta oficial do Bun afirmou que o trabalho levou cerca de 11 dias, contando com implementação paralela, revisão adversarial e o conjunto de testes independente de linguagem já existente no projeto.

Quantas linhas de código foram alteradas na migração do Bun?

O pull request mesclado mostra mais de um milhão de novas linhas de código, juntamente com linhas excluídas e modificadas. Apenas a contagem de linhas não mede qualidade, portanto, os indicadores mais importantes são os resultados da compilação, testes entre plataformas, comportamento, uso de memória, tamanho do binário e o tratamento de regressões após a mesclagem.

Qual foi o custo da migração de IA do Bun?

Com base em 5,9 bilhões de tokens de entrada não armazenados em cache e 690 milhões de tokens de saída, a Anthropic estima o custo da API em cerca de 165 mil dólares. O custo real da organização pode variar devido a acordos de preços, infraestrutura interna, horas de trabalho humano, uso de CI e correções pós-mesclagem.

O que é um manual de regras de migração?

Um manual de regras de migração é um conjunto de políticas legíveis por máquina ou por agente que descrevem como os padrões da linguagem de origem mapeiam para a implementação de destino. Abrange tipos, propriedade, erros, interfaces, nomenclatura, casos não suportados, decisões de arquitetura e outras regras que os agentes de implementação devem seguir consistentemente.

Por que usar um revisor adversarial?

Agentes de implementação têm contexto e inércia que podem torná-los tendenciosos a aceitar suas próprias soluções. Um revisor adversarial trabalha em um contexto independente e é instruído a encontrar falhas, violações de regras e diferenças de comportamento, em vez de ajudar a mesclar o código.

Esse método funciona se não houver um conjunto de testes existente?

É possível, mas a equipe deve estabelecer outro árbitro objetivo. Uma plataforma de teste de consistência pode executar cenários reais em ambas as implementações e comparar as saídas, enquanto novos testes de ponta a ponta podem expor falhas que as verificações de tradução estática ignoram.

Todas as bases de código legadas são adequadas para migração com IA agora?

Não. A migração ainda requer benefícios mensuráveis, uma implementação de referência estável, validação objetiva, orçamento suficiente e um plano de reversão aceitável. Sistemas com testes fracos, comportamento não documentado, requisitos em rápida mudança ou restrições críticas de segurança podem precisar de muita preparação, ou ser inviáveis com as capacidades atuais de IA.

O trabalho de preparação necessário antes que o agente possa ajudar de forma responsável.

Ferramentas relacionadas

• Claude Code: A ferramenta de codificação agente da Anthropic para entender repositórios de código, editar arquivos, executar comandos e coordenar o desenvolvimento.
• Kit de ferramentas de migração de código da Anthropic: Prompts, modelos e scripts oficiais para construir fluxos de trabalho de migração de linguagem.
• Plugin de modernização do Claude Code: Plugin oficial focado em atualizações de framework e modernização de sistemas legados (em vez de portabilidade completa de linguagem).
• Bun: Conjunto de ferramentas JavaScript e TypeScript usado no estudo de caso de migração de um milhão de linhas de código da Anthropic de Zig para Rust.
• Rust: A linguagem de sistema com segurança de memória escolhida para a nova implementação do Bun.
• Zig: A linguagem de programação de sistema usada pelo Bun antes da migração para Rust.
• TypeScript: A linguagem JavaScript com tipos usada nos exemplos de migração de Python da Anthropic.

Links relacionados

• Guia de migração de código em larga escala da Anthropic: A metodologia oficial de seis etapas e dois estudos de caso de migração da Anthropic.
• Reescrevendo o Bun em Rust: Explicação técnica detalhada de Jarred Sumner sobre a motivação, ciclo de orquestração, processo de revisão e resultados da migração.
• Pull request da reescrita do Bun em Rust: Pull request público mesclado contendo a migração em larga escala para Rust.
• Kit de ferramentas de migração de código para uso com Claude Code: Kit de ferramentas de início geral destilado do processo de migração.
• Introdução aos fluxos de trabalho dinâmicos: Explicação da Anthropic sobre fluxos de trabalho multiagente adaptativos de longa duração no Claude Code.
• Documentação do Claude Code: Documentação oficial de instalação, fluxo de trabalho, configuração e uso.
• Melhores práticas do Claude Code: Guia prático sobre contexto do repositório, sessões paralelas, validação e fluxo de trabalho do agente.

Resumo

As práticas recentes de migração da Anthropic mostram que projetos de transposição de linguagem podem ser reestruturados em torno de workflows de agentes, em vez de depender de reescritas manuais longas e únicas. Tanto a migração do Bun de Zig para Rust quanto o projeto da Anthropic de Python para TypeScript dependem de implementação paralela, revisão adversarial, verificação determinística e regeneração repetida.

A parte reutilizável é o fluxo: construir um avaliador, definir regras, mapear dependências, estressar os métodos, traduzir em lotes retomáveis, compilar, executar e comparar comportamentos. Quando o mesmo defeito aparece repetidamente, corrija a regra ou o workflow que o gerou, em vez de corrigir manualmente cada saída.

Essa abordagem ainda exige orçamento considerável, testes robustos, permissões controladas e julgamento humano no nível da arquitetura. Ela reduz os custos de migração, mas não elimina o trabalho de engenharia.

Responsabilidade.

O ponto central é simples: uma migração confiável de IA vem de ciclos de produção verificáveis, não de um único prompt que pede ao modelo para reescrever toda a base de código.