Os 8 Níveis de IA no Desenvolvimento: Guia de Referência
Um guia completo sobre os 8 níveis de desenvolvimento assistido por IA baseado no framework de Steve Yegge, com autoavaliação e recomendações práticas para subir de nível.
1. Por que essa escala é diferente
A maioria dos estudos que mede 20–30% de ganho de produtividade com IA está medindo o nível errado. Eles mediram devs nos níveis 1 e 2, numa escala de 8. A observação de Steve Yegge (ex-Google, ex-Amazon): de nível para nível, o que muda é o modelo mental, como você pensa e como usa as ferramentas. A ferramenta é constante.
A diferença entre um dev de nível 2 e um de nível 4, com a mesma ferramenta, não é de 20%. É de aproximadamente 5 vezes mais. Não porque o nível 4 digita mais rápido: ele faz um trabalho fundamentalmente diferente.
A ferramenta importa menos do que o nível que você opera.
Você não pode pular níveis. Cada um exige o anterior. Tentar ir do nível 2 direto para o 5 sem passar pelo 3 e 4 vai falhar: não por causa da ferramenta, mas porque o modelo mental necessário ainda não está lá.
2. Níveis 0–2: Você ainda é o único que pensa
Nestes três níveis, a IA não mudou fundamentalmente como você trabalha. Você ainda decide, implementa e executa. A IA é uma ferramenta nova na caixa, nada mais.
| Nível | Nome | Comportamento | O que acontece |
|---|---|---|---|
| 0 | Negacionista | Não usa IA. Acha que é hype, que vai "atrapalhar o raciocínio" | A posição vai atrasar a carreira. Devs ao redor ficam mais produtivos. |
| 1 | Cauteloso | Usa autocomplete na IDE. Aceita ou rejeita sugestão por sugestão. | Usa ~5% do potencial da ferramenta. A maioria dos devs está aqui. |
| 2 | Perguntador | Usa o chat da IA para tirar dúvidas. Substitui o Stack Overflow. | Respostas mais rápidas e com mais contexto que o Google. Mas ainda faz 100% do trabalho manualmente. |
O stuck point do nível 1 é accept-fatigue: sugestões chegam a cada digitação, o dev aceita por reflexo sem revisar, e regressões passam despercebidas até o code review.
O stuck point do nível 2 é context loss at the copy-paste boundary: cada transcrição do chat de volta para o editor perde informação que o modelo tinha e introduz erros de transcrição.
3. A virada (nível 3 → 4): onde a maioria trava
Nível 3: Delegador básico
Começa a pedir para a IA escrever código, mas pede uma coisa por vez. Copia, cola, adapta na mão. O ciclo é lento: você ainda está microgerenciando cada linha.
"faz uma função que valida CPF"
→ IA gera o código
→ você copia, cola, valida manualmenteNível 4: Diretor
O modelo mental muda completamente. Você para de pedir funções isoladas e começa a especificar comportamento:
"preciso de um sistema que valide CPF.
Aqui estão os testes que definem válidos/inválidos,
com máscara, sem máscara, casos de exceção.
Aqui está o contexto do projeto."
→ IA implementa blocos inteiros
→ você revisa no final
→ vai para a próxima task enquanto a IA trabalhaA transição é de responsabilidade: no nível 4, o trabalho passa a ser especificar comportamento e validar resultado.
| Nível 3: Delegador | Nível 4: Diretor | |
|---|---|---|
| O que pede | "faz essa função" | "spec + testes + contexto" |
| Como valida | linha por linha | resultado final |
| Ciclo | lento, microgerenciado | você vai pra próxima task |
| O que muda | ferramenta | modelo mental |
Por que a maioria trava aqui
Porque o nível 4 exige mais conhecimento de engenharia, não menos. Você precisa:
- Confiança para deixar a IA trabalhar sem supervisionar cada passo
- Contexto suficiente do sistema para escrever uma spec coerente
- Experiência para definir testes que capturem o comportamento correto
Se você não sabe o suficiente sobre o sistema, não consegue especificar: e volta para o nível 3.
4. Níveis 5–7: você quase não escreve código
Nestes níveis, a relação com o código muda completamente.
| Nível | Nome | Modelo mental | O que a IA faz |
|---|---|---|---|
| 5 | Orquestrador | Tech lead | Navega o projeto, lê arquivos, roda testes, corrige erros autonomamente. Você define a task de alto nível. |
| 6 | Multiagente | Eng manager | Múltiplos agentes rodam em paralelo, cada um numa task diferente. Você gerencia, revisa, prioriza. |
| 7 | Arquiteto | Staff / CTO | Define a arquitetura, contratos de API, especificações do sistema, critérios de qualidade. Agentes constroem tudo. Raramente toca em código. |
O nível 5 representa o que ferramentas como Claude Code, Cursor Agent Mode e GitHub Copilot Agent Mode fazem: a IA não só escreve código, mas navega o codebase, executa comandos, corrige erros de compilação e teste em loop, e responde a mudanças em múltiplos arquivos.
O nível 6 é onde o fluxo se torna paralelo. Em vez de um agente que faz tudo em sequência, você distribui o trabalho: um agente refatora o backend, outro implementa uma feature, outro escreve testes de integração.
O nível 7 adiciona uma camada de abstração. O arquiteto quase nunca escreve código: ele define contratos e diretrizes, e os agentes constroem o sistema a partir dessas especificações.
O gargalo da verificação
Quanto mais alto o nível, maior o custo de verificação. Revisar o trabalho de 10 agentes paralelos é mais difícil que revisar o trabalho de um. Os modos de falha comuns no nível 7:
- Spec drift: cada agente trabalha do prompt que recebeu, e as specs divergem sem sinalização
- Trabalho duplicado: agentes reimplementam utilidades que outros já escreveram
- Conflitos de merge: 10 agentes escrevendo nos mesmos arquivos produzem conflitos que demoram mais para resolver que o trabalho original
- Review collapse: o revisor humano não consegue acompanhar 10 PRs paralelos
5. O paradoxo: mais IA, mais skill
| Nível | Habilidade necessária |
|---|---|
| 1–2 | Sintaxe da linguagem, saber perguntar |
| 3 | Saber ler e adaptar código gerado |
| 4 | Saber especificar comportamento com testes e contexto |
| 5 | Entender o sistema como um todo para delegar tarefas de alto nível |
| 6 | Saber gerenciar prioridades, distribuir trabalho e revisar em paralelo |
| 7 | Visão arquitetural, capacidade de desenhar sistemas complexos |
Dev ruim com IA faz as coisas funcionarem: só mais rápido. Dev bom com IA faz as coisas muito melhor: e muito mais rápido.
A IA amplifica o skill, não substitui.
6. Autoavaliação: onde você está?
Atribua uma nota de 0 a 2 para cada afirmativa (0 = nunca, 1 = às vezes, 2 = consistentemente):
| # | Afirmativa | Score (0–2) |
|---|---|---|
| 1 | Uso autocomplete ou chat de IA diariamente no trabalho | |
| 2 | Aceito sugestões da IA sem revisar cada linha | |
| 3 | A IA edita arquivos diretamente: reviso diffs em vez de escrever código | |
| 4 | Descrevo objetivos para a IA em vez de especificar passos de implementação | |
| 5 | Trabalho principalmente no terminal/CLI com agentes, não na IDE | |
| 6 | Rodo 2+ agentes simultaneamente em tarefas diferentes | |
| 7 | Escrevo specs, AGENTS.md, ou uso ferramentas de orquestração para coordenar agentes | |
| 8 | Testes automatizados e constraints de confiança governam o que a IA pode fazer | |
| 9 | Trabalho paralelo de agentes mergea limpo sem conflitos frequentes | |
| 10 | Meço sucesso por velocidade de decisão e confiabilidade do sistema, não por linhas de código |
Interpretação do score:
| Score | Nível aproximado | Foco |
|---|---|---|
| 0–4 | Níveis 1–2 | Aumentar confiança com inline edits e edit mode |
| 5–8 | Níveis 3–4 | Experimentar ferramentas agentic CLI-first |
| 9–13 | Nível 5 | Preparar para workflows paralelos |
| 14–17 | Níveis 6–7 | Investir em orquestração spec-driven e verificação |
| 18–20 | Nível 8 | Focar em governança, observabilidade e escala |
7. Como subir um nível: recomendações por estágio
| Você está no... | Faça isso |
|---|---|
| Nível 2 | Delegue um tipo de task inteira. Ex: escreva a spec do que um teste precisa cobrir e deixe a IA escrever o teste sozinha. |
| Nível 3 | Escreva uma spec completa para a próxima feature antes de pedir para a IA. Defina os testes primeiro. Avalie a qualidade do output. |
| Nível 4 | Use Claude Code ou equivalente por uma semana numa task real. Deixe a IA navegar o código sem microgerenciar cada arquivo. |
| Nível 5 | Experimente rodar 2 agentes em paralelo em tarefas isoladas e bem escopadas: backend refactor, geração de testes, documentação. |
| Nível 6 | Estabeleça specs vivas (living specs) como fonte única de verdade. Invista em infraestrutura de verificação automatizada antes de escalar. |
| Nível 7 | Construa ou adote um orquestrador customizado com task queue compartilhada, checkpointing e verificação automatizada. |
Critérios para uma boa spec (nível 4+)
- Goal statement: uma frase descrevendo o resultado visível ao usuário
- Scope boundary: quais arquivos, serviços ou módulos estão dentro e fora do escopo
- Interface contracts: assinaturas de função ou shapes de API que o agente precisa respeitar
- Acceptance tests: testes que o agente deve rodar localmente antes de declarar a task completa
- Rollback plan: como reverter a mudança se a verificação falhar
Uma spec ruim é um parágrafo de prosa sem boundary e sem testes. O agente aceita, produz código plausível, e falha sem aviso.
Referências
- Steve Yegge: 8 Levels of AI-Assisted Development, discutido em entrevistas com Gergely Orosz (The Pragmatic Engineer) e no ensaio original sobre coding agents
- The Pragmatic Engineer: "Steve Yegge's 8 Levels of AI Development: Where's Your Team?" (Abr 2026)
- Addy Osmani: Transição de conductor para orchestrator em agentes de IA
- Andrej Karpathy: "Verifiability" essay sobre o novo paradigma de programação
- Boris Cherny: Workflow de múltiplos terminais com Claude Code
- Anthropic: Documentação do Claude Code SDK e Agent Teams
@developer.israel · Os 8 Níveis de IA · Steve Yegge: 15 de junho de 2026