Quando você deve pedir a uma IA para escrever código do zero versus apenas revisar ou refatorar código existente?

Question

Accepted Answer

A regra de ouro: deixe a IA **escrever** onde erros são baratos e óbvios, e use-a para **revisar/refatorar** onde erros são caros ou sutis. O fator decisivo é quanto custa verificar o resultado.

## Quando deixar que ela escreva do zero

- **Greenfield e boilerplate** — um novo utilitário, um arquivo de configuração, um endpoint CRUD, uma regex. Não há contexto oculto que possa quebrar.
- **APIs/bibliotecas desconhecidas** — a IA conhece a superfície de uma biblioteca que você não conhece, e você verifica contra a documentação.
- **Código descartável/protótipo** — velocidade importa mais que perfeição.

Nesses casos o custo de um bug é baixo e você pode ler o resultado de cima a baixo.

## Quando usá-la apenas para revisar/refatorar

- **Lógica crítica de negócio** — faturamento, autenticação, cálculos monetários. Uma resposta errada com aparência plausível é perigosa.
- **Código sutil** — concorrência, segurança, algoritmos pesados em casos extremos onde "parece certo" não é "é certo".
- **Grandes sistemas existentes** — a IA não consegue ver todos os invariantes que seu código depende, então gerar dentro dele arrisca quebras silenciosas.

Aqui você mantém a IA como um **segundo par de olhos**: ela sugere, você decide.

```text
                 Cost of a bug LOW          Cost of a bug HIGH
New code          ✅ let AI write           ⚠️ AI drafts, you verify hard
Existing code     ✅ AI refactors           ✅ AI reviews, you write the change
```

## Tradeoffs e riscos

Escrever do zero é rápido mas a IA pode inventar APIs (**alucinação**) ou perder contexto que não consegue ver. Revisar é mais seguro mas mais lento e apenas tão bom quanto o contexto que você fornece. De qualquer forma você é o **autor responsável** — a IA é uma ferramenta, não a signatária do commit.

## Por que isso importa

Julgar mal isso é onde o desenvolvimento assistido por IA falha: pessoas deixam a IA gerar lógica crítica que não conseguem verificar completamente, ou escrevem manualmente boilerplate trivial que a IA poderia ter produzido em segundos. Fazer corresponder o modo (**escrever** vs **revisar/refatorar**) ao **custo de estar errado** mantém você rápido nas coisas baratas e cuidadoso nas perigosas. A habilidade sendo testada é julgamento sobre onde gastar seu esforço de verificação — não se você consegue fazer prompt de uma IA.