← Guias · English · 日本語 · 中文

Atualizado 2026-11-20

Nesta página
  1. O playbook oficial
  2. Passo 1 — Verifique se sua migração se qualifica
  3. Passo 2 — Fatie
  4. Passo 3 — Escreva a transformação como um skill
  5. Passo 4 — Rode sessões paralelas
  6. Passo 5 — Vigie a taxa de erro, não a barra de progresso
  7. Checklist de verificação
  8. Armadilhas
  9. Teste de conhecimento
  10. Demonstração — o loop de migração executado em série, no Devin CLI v3000.14 (swe-2-flash-medium)
  11. Fontes

Guia 11 — Migrações em escala

Objetivo: rodar uma migração grande (linguagem, framework, banco de dados, dependência, arquitetura) como centenas de PRs pequenos verificados em vez de uma reescrita heroica. Nível: intermediário → avançado Fontes: Best Practices · Migration & Modernization · exemplos de migração: Java upgrades, COBOL, SAS→PySpark, JS→TS, NoSQL→SQL · caso Nubank

O playbook oficial

Os docs do próprio Devin são diretos sobre o que escala: wide & shallow vence tall & deep. Uma migração é o trabalho wide-and-shallow canônico — a mesma pequena transformação aplicada a centenas de unidades independentes.

migração ──► fatiar em unidades isoladas (<90 min cada)
                    │
           ┌────────┴────────┐
           ▼                 ▼
      skill para a      sessões paralelas,
      transformação     uma fatia cada
           │                 │
           └────► verificar por fatia (testes/build/CI)
                           │
                 revisão humana → merge → repete

Passo 1 — Verifique se sua migração se qualifica

Dos critérios oficiais — a maioria deve valer:

Não se qualifica: uma reescrita de repo inteiro onde tudo precisa aterrissar de uma vez.

Passo 2 — Fatie

A fatia é a menor unidade atômica — um arquivo, um notebook, um módulo:

Regra Por quê
< 90 minutos de engenharia manual por fatia A confiabilidade do Devin é por fatia
Independente + retrocompatível Fatias rodam em paralelo e mergeiam em qualquer ordem
Cada fatia carrega sua própria verificação Sem verificação, sem automação — este é o gate de falha

Exemplo (oficial): uma migração REST→GraphQL de 50 arquivos → escopar, dividir em pacotes de trabalho sem conflitos, rodar em paralelo.

Passo 3 — Escreva a transformação como um skill

Um skill = a receita repetível que toda sessão roda. Exemplo oficial (Java 7→8, abreviado):

## Procedure
1. Verify the project is on Java 7
2. Install the Java 8 JDK
3. Update build configuration
4. Identify and replace deprecated Java 7 APIs
5. Analyze for Java 8 enhancement opportunities
6. Update unit tests
7. Test thoroughly
8. Update documentation
9. Build and verify

Escreva o seu com: passos explícitos, uma referência ponta a ponta (um guia ou vídeo) e múltiplos exemplos de código antes/depois — pares entrada/saída são o sinal de maior qualidade que você pode dar.

Passo 4 — Rode sessões paralelas

Com o skill fixado, distribua fatias entre sessões — a API ou as sessões filhas de um Bot (Guia 4). Cada fatia → uma sessão → um PR. A revisão humana faz o gate do merge em main.

Em escala os números compõem: a migração ETL de milhões de linhas da Nubank rodou esse loop até 8–12× de eficiência — e um Devin fine-tuned cortou o tempo por tarefa de ~40 → ~10 minutos.

Passo 5 — Vigie a taxa de erro, não a barra de progresso

Taxas de erro pequenas compõem através de milhares de fatias. Opere num dashboard, não em vibes:

Checklist de verificação

Armadilhas

Teste de conhecimento

  1. Por que fatias "wide and shallow" em vez de "deep and complete"? (Cada fatia precisa aterrissar verde — um PR verificado de 90 minutos compõe; um mega-branch de 3 dias apodrece contra o main.)
  2. Por que toda fatia precisa de sua própria verificação? (Sem prova por fatia, uma migração de 500 PRs é 500 diffs não verificados — a superfície de falha multiplica em vez de dividir.)
  3. A Nubank reportou 8–12× de eficiência — o que tornou esse número crível e não marketing? (Metodologia publicada: tempos de estágio medidos antes/depois em pipelines ETL reais, não uma projeção.)

Demonstração — o loop de migração executado em série, no Devin CLI v3000.14 (swe-2-flash-medium)

A parte de escala (centenas de sessões paralelas) precisa de cota de nuvem — o loop não, então rodamos serialmente na cota gratuita. migrate-demo: quatro CLIs em optparse (greeter, calc, backup, report), um teste de comportamento por ferramenta e a transformação escrita em .devin/skills/optparse-to-argparse/SKILL.md. Prompt: "migrate as independent slices … run the test suite, and only move to the next tool when it's green."

Vídeo (41 s, sem som): baseline → skill invocado → 4 fatias, suíte verde após cada uma → zero optparse.

O loop de fatias completo — cada ferramenta migrada, suíte verde após cada uma, resumo fiel à receita

1. Baseline — 4 ferramentas optparse, 7 testes de comportamento verdes 1. Baseline: 4 ferramentas em OptionParser, 7 testes, uma receita-skill commitada

2. Skill invocado automaticamente de .devin/skills — primeiro lê todas as ferramentas e os testes 2. Invoked skill optparse-to-argparse — a receita dirige a execução

3. O loop de fatias — "Green. Now calc.py — it relies on rest for positional args, so parse_known_args preserves that shape." 3. Verificação por fatia; ele mesmo notou que calc.py precisa de parse_known_args para manter operandos posicionais

4. Verificado após /exit — 4 arquivos migrados, +18/−18, nenhuma referência a optparse, nada commitado 4. Quatro diffs pequenos e verificados — a disciplina de fatias, sem a frota paralela

Fontes