Migrações de código em escala: como Claude Code reduz semanas para $100k

A Anthropic rodou um millão de linhas de código de Zig pra Rust em menos de 2 semanas — e passou em 100% dos testes antes do merge. Sem humano arbitrando cada falha. Sem burnout, sem ".js em production que ninguém toca". Isso seria impossível 12 meses atrás. Custaria $3 a $4 milhões em 4 anos. Hoje é tens of thousands e 2 semanas.

Na minha visão, essa é a mudança mais pragmática que a IA trouxe pro desenvolvimento em 2026. Não é "código que escreve código". É agents que viram a linguagem de um programa de um lado pro outro, e humanos viram arbítros de pattern, não de bug. Vou quebrar como isso funciona.

O que é realmente uma migração de código em escala

Antes de 2024, uma migração de linguagem em larga escala era projeto de ano inteiro: 1 time rodando em paralelo, outro mantendo production, teste final feito em staging e depois a bala direto. Porque se você errar, perde mês. Custo operacional gigante, então virou projeto de 4 anos pra justificar o investimento.

Agora é diferente. Claude Code consegue pegar um arquivo Zig, entender suas dependências, transformar pra Rust com as mesmas semânticas, e deixar o compilador + test suite arbitrarem se funcionou. Nenhum humano relê cada linha. O agente tenta, falha, lê o erro de compilação, ajusta a regra, tenta de novo.

O case: Bun rodou 1 milhão de linhas em 14 dias

A Anthropic trabalhou na migração Zig → Rust do Bun (runtime JavaScript, ~1M de linhas). Equipe pequena. 2 semanas. Resultado: código compilando, 100% do test suite passando. Nenhum "acordar é o PR passando porque achei uma edge case".

O legal não é só a velocidade. É que o projeto era economicamente iniviável antes. Bun teria que viver em Zig e sofrer com performance de compilação, ou investir $3M em engineers durante 4 anos. Terceira opção agora: 2 semanas, tens of thousands. Projeto sai da pilha "talvez em 2027".

Por que funciona: você não corrige código, corrige processo

Aqui está o insight que muda tudo: o agente não precisa ser infalível. Ele precisa ser capaz de ler feedback objetivo (erro de compilador, teste falhando) e iterar.

Arquivo Zig falha ao compilar em Rust? Você não chama humano. Você não apita e faz agent parar. Você muda a **regra** que gerou aquele trecho — o padrão de transformação. Depois roda tudo de novo. Se 10 mil linhas usavam aquele padrão errado, agora todas as 10 mil se consertam. É refactor sistêmico automático.

Humanos focam em padrão, não em exceção. Agente itera. Compilador arbitra. Ninguém fica preso em "é um bug ou era intended mesmo?". É pragmático.

Os modelos que fazem a diferença: Fable 5 e Opus 4.8

A Anthropic usou Claude Fable 5 (o modelo rápido, barato) pro gross-pass — primeira transformação de código. Depois Claude Opus 4.8 pra iterar nos erros de compilação, entender o contexto mais profundo e ajustar regras. Workflow em camadas: speed no start, power quando precisa.

Isso reduz custo (Fable é 10x mais barato que Opus) e keeps latency baixa. Projeto de 1M de linhas não trava esperando resposta — Fable processa chunks em paralelo, e Opus entra só pra desempate.

As 6 fases estruturadas de uma migração automática

A Anthropic documentou o pipeline em 6 steps (não é mágica, é engineering disciplinado):

(1) **Build rulesets and dependency maps** — entender como o código tá conectado, quais são os patterns pra transformar. Humano + agent juntos.

(2) **Stress-test the rules** — pega pedaços pequenos, tenta transformar, vê onde quebra. Antes de rodar 1M de linhas.

(3) **Translate files** — Fable 5 rodando em paralelo. Cada arquivo, cada chunk dum arquivo, transformação linha por linha ou função por função conforme a rule.

(4) **Compile** — rodar o compilador da linguagem target (rustc, tsc, whatever). Erros viram input pra iteração, não pra humano.

(5) **Smoke tests** — run a subset de testes rápido, vê se comportamento basic tá OK. Reduz loop de feedback.

(6) **Behavioral matching** — full test suite passa? OK, merge-ready. Se não passa, volta pro step 2 com ruleset revisado.

Isso é pipeline, não arte. Mensurável, repetível, escalável.

Por que isso importa pra você agora

Três takeaways pra você guardar:

(1) **Code that looked economically doomed agora tá na pauta.** Aquele monolito em Python de 200k linhas que ninguém toca? Talvez em 2027 a bill seja $150k e 4 semanas, não $2M e 3 anos. Decisions mudam.

(2) **Verification é o novo "release criteria".** Não é "qual versão do Python?", é "tudo compila? Todos os testes passam?" Humano não tá na loop arbitrando. Compiler arbitrates. Isso muda como você design refactoring.

(3) **AI não escreve codigo.** AI executa processo. Quem estrutura o processo bem ganha. É engenharia pura — a IA é só o executor. Continua valendo know o seu codebase, seu compilador, seus testes.

Conclusão

Migrações de código em larga escala viraram viáveis porque AI agents conseguem rodar processos estruturados melhor que humano, e métricas objetivas (compilador, testes) remover a necessidade de arbitragem manual. É pura engenharia de processo. E é aqui, agora.

Quer ver a história completa de como a Anthropic fez isso? How Anthropic runs large-scale code migrations with Claude Code.