Planejar, implementar e revisar com IA
Trabalhar com IA em fatias pequenas: pedir o plano antes do código, ler o diff como quem revisa e só seguir com evidência de que funciona.
Cerca de 15 min · Revisado em
Ao final, você vai conseguir
- Dividir uma mudança em fatias pequenas, com limites claros e resultado observável
- Pedir um plano curto e a forma de verificação antes de qualquer código
- Ler um diff procurando arquivos fora do escopo e testes alterados para passar
- Testar um caso-limite pensado a partir do requisito e corrigir o código sugerido
Uma IA de programação escreve em dez segundos o que você levaria uma tarde para digitar. O problema é que ela também erra em dez segundos, e um erro escondido no meio de duzentas linhas pode passar despercebido até chegar à pessoa usuária. Quem trabalha bem com IA não pede o sistema inteiro de uma vez: divide o trabalho em fatias pequenas, revisa cada uma e só segue quando tem evidência de que funciona. É esse jeito de trabalhar que você vai praticar agora.
Uma fatia de cada vez
Com IA é igual. Um assistente de código é uma IA que conversa sobre o seu código e sugere trechos. Um agente de código vai além: ele lê os arquivos do projeto, edita, roda comandos no terminal e mostra o resultado. Quanto mais ele consegue fazer sozinho, mais importa limitar o tamanho de cada pedido.
Uma fatia (ou recorte) é uma mudança pequena que entrega algo observável: um botão que passa a funcionar, uma regra nova com um teste, um erro tratado. Ela cabe numa revisão de poucos minutos e, se der errado, é fácil desfazer.
Você está construindo a lojinha da trilha e quer frete grátis para pedidos grandes. Qual pedido para a IA é uma boa fatia?
- “Implemente a regra de frete grátis a partir de R$ 100 na função
calcularFretee um teste para ela. Não mexa em outros arquivos.” - “Melhore o checkout da loja.”
- “Crie o carrinho, o cálculo de frete, o cupom de desconto e o pagamento por Pix.”
O ciclo de trabalho em parceria
Trabalhar com um agente é repetir um ciclo curto: planejar, implementar uma fatia, revisar o que mudou, testar e guardar o passo num commit (o registro de uma mudança no Git). Depois, a próxima fatia. Veja o ciclo acontecendo.
Uma fatia da regra de frete, do pedido ao commit
- Você → Agente: Pedido + limites. Você descreve a fatia, o resultado esperado com um exemplo e quais arquivos podem mudar. E pede um plano antes de qualquer código.
- Agente → Você: Plano em 3 passos. O agente propõe: alterar
calcularFrete, criar um teste e rodar a suíte. Você lê, corrige o que não faz sentido e aprova só o primeiro passo. - Agente → Código: Edita frete.js. O agente altera o arquivo. Até aqui nada foi guardado no Git: a mudança está só na sua pasta, fácil de desfazer.
- Agente → Testes: npm test. O agente roda os testes do projeto para conferir o próprio trabalho.
- Testes → Agente: 1 teste falhou. Um teste antigo quebrou. O agente lê a mensagem e ajusta o código. Repare: quem decide se o ajuste está certo ainda é você.
- Agente → Você: Diff + saída dos testes. O agente mostra o que mudou e o resultado dos comandos. Você lê o diff linha por linha.
- Você → Testes: Você roda de novo. Você mesmo roda os testes e abre a aplicação para ver o frete na tela. A palavra do agente não é evidência; a saída do comando é.
- Você → Você: Commit da fatia. Com tudo conferido, você faz o commit. Se a próxima fatia der errado, este ponto seguro continua guardado.
Coloque em ordem o ciclo de uma fatia feita em parceria com um agente.
- Descrever a fatia, o resultado esperado e os limites
- Ler o plano proposto e ajustar antes de aprovar
- Deixar o agente implementar só o passo aprovado
- Ler o diff linha por linha
- Rodar os testes e conferir o comportamento você mesmo
- Fazer o commit e só então partir para a próxima fatia
Plano primeiro, código depois
Pedir o plano antes do código parece burocracia, mas é o passo mais barato do ciclo. Corrigir uma frase do plano leva segundos; desfazer cinco arquivos editados na direção errada leva muito mais.
Um modelo de pedido para começar uma fatia
Quero implementar [mudança pequena] neste projeto.
Contexto: [arquivos relevantes, comportamento atual e versão].
Resultado esperado: [exemplo de entrada e saída].
Limites: [arquivos que podem mudar e o que deve ser preservado].
Primeiro proponha um plano curto e como vamos verificar.
Depois trabalharemos uma etapa por vez.
Ao implementar, mostre o diff, explique as decisões
e informe os comandos executados e seus resultados.O agente responde com um plano que inclui “atualizar a biblioteca de testes para a versão mais nova”. Por que vale parar aqui, antes de qualquer código?
Porque isso não faz parte da fatia. Atualizar uma dependência pode quebrar outras partes do projeto e mistura duas mudanças num diff só. No plano, basta responder “sem atualizar dependências” e seguir. Depois do código feito, separar as duas coisas dá bem mais trabalho.
O plano também é a hora de decidir o que você mesmo escreve. Se você está aprendendo, a parte central do exercício é sua: é ela que você precisa saber explicar numa entrevista. Tarefas repetitivas ou periféricas podem ser delegadas, desde que revisadas.
Enquanto você aprende, o que é melhor fazer você e o que pode delegar à IA para depois revisar?
Faça você · Pode delegar e revisar
- A regra principal que o exercício quer ensinar
- Decidir o que entra e o que fica fora da fatia
- Um caso de teste escrito a partir do requisito, sem olhar o código gerado
- Renomear uma variável em vários arquivos
- Gerar dados de exemplo para testar uma tela ou consulta
- Um rascunho da seção “Como rodar” do README, que você confere
Lendo um diff como quem revisa
O diff é a lista do que mudou entre duas versões de um arquivo. Você viu o Git na aula de Git do zero; aqui o foco é ler o diff com olhar de revisão. Linhas com - saíram, linhas com + entraram, e as linhas sem sinal são contexto, só para você se localizar.
Um diff pequeno, como o git diff mostra no terminal.
diff --git a/src/preco.js b/src/preco.js
--- a/src/preco.js
+++ b/src/preco.js
@@ -1,3 +1,5 @@
function formatarPreco(valor) {
- return 'R$ ' + valor;
+ return valor.toLocaleString('pt-BR', {
+ style: 'currency', currency: 'BRL',
+ });
}- Qual arquivo: O cabeçalho diz qual arquivo mudou.
a/é a versão antiga eb/é a nova. Primeira pergunta da revisão: este arquivo deveria mesmo ter mudado nesta fatia? - Onde: Um trecho alterado. Lê-se: na versão antiga, a partir da linha 1, 3 linhas; na nova, a partir da linha 1, 5 linhas. Um diff grande tem vários desses blocos.
- Contexto: Começa com espaço: a linha não mudou. Ela aparece só para você saber em que parte do código está.
- Linha removida: Começa com
-. Era assim antes. Pergunte-se: o que este código fazia, e alguém dependia disso? - Linhas adicionadas: Começam com
+. É o código novo. Leia como se você fosse responder por ele: você sabe o quetoLocaleStringfaz? Se não, confira na documentação antes de aceitar.
O agente avisa: “Pronto, todos os testes passam.” Revisando o diff, você encontra este trecho. O que fazer?
--- a/tests/frete.test.js
+++ b/tests/frete.test.js
@@ -4,3 +4,3 @@
test('frete grátis a partir de R$ 100', () => {
- expect(calcularFrete(100)).toBe(0);
+ expect(calcularFrete(100)).toBe(12.9);
});- Rejeitar essa parte: o teste foi alterado para aceitar o comportamento errado
- Aceitar, porque os testes estão passando
- Apagar o teste, já que ele estava atrapalhando
- Aceitar, porque a IA deve conhecer melhor a regra de frete
Complete os comandos que fecham uma fatia: ver o que mudou, testar, preparar e guardar.
git ____ # ver o que mudou, linha por linha
npm ____ # rodar os testes você mesmo
git ____ src/frete.js tests/frete.test.js
git ____ -m "Frete grátis a partir de R$ 100"Mão na massa: revise o que a IA escreveu
A IA recebeu o pedido “frete grátis para pedidos a partir de R$ 100; abaixo disso, R$ 12,90” e devolveu a função abaixo, com dois exemplos que funcionam. Sua tarefa é revisar como faria numa equipe: comparar o código com o requisito, testar um caso que a IA não testou e corrigir.
Revise a função de frete
Rode os exemplos e compare com o requisito. Acrescente um console.log para o caso de exatamente R$ 100, encontre o erro e corrija a função.
// Pedido: "Frete grátis para pedidos a partir de R$ 100.
// Abaixo disso, o frete custa R$ 12,90."
// Código sugerido pela IA:
function calcularFrete(subtotal) {
if (subtotal > 100) {
return 0;
}
return 12.9;
}
// Exemplos que vieram junto com a sugestão:
console.log('R$ 50 ->', calcularFrete(50));
console.log('R$ 150 ->', calcularFrete(150));
// Escreva aqui o seu caso de teste:
- O console mostra o frete para um pedido de exatamente R$ 100
calcularFrete(100)devolve0, como pede o requisito- Abaixo de R$ 100 o frete continua
12.9e acima continua0
Os dois exemplos da IA passavam e o erro estava lá mesmo assim. O que esse exercício ensina sobre os exemplos que vêm junto com o código?
Que eles costumam testar o caminho fácil, longe da fronteira. Erros de > no lugar de >= só aparecem no caso-limite, o valor exato onde a regra muda. Por isso o seu teste, pensado a partir do requisito, vale mais do que os exemplos da mesma proposta. Esse caso vira um teste automatizado no projeto, para o erro nunca voltar.
Fechamento
- Trabalhe com IA em fatias pequenas: uma mudança observável, com limites claros, que cabe numa revisão de poucos minutos.
- O ciclo é planejar, implementar um passo, ler o diff, rodar os testes e fazer o commit antes da próxima fatia.
- Peça o plano antes do código: corrigir uma frase do plano custa muito menos que desfazer arquivos editados.
- No diff, desconfie de arquivos fora do escopo e de testes alterados para passar.
- A evidência é a saída dos comandos que você roda, e um caso de teste pensado por você a partir do requisito.
Uma fatia em parceria, do plano ao commit
No projeto que você está construindo na sua trilha, escolha uma mudança pequena e faça o ciclo completo com uma ferramenta de IA. Ao final, você deve conseguir explicar cada linha do diff.
- Escreva o pedido com contexto, resultado esperado e limites, e peça um plano antes do código
- Ajuste o plano e aprove só o primeiro passo
- Leia o diff inteiro e rejeite ou ajuste pelo menos uma sugestão, anotando o motivo
- Acrescente um caso de teste que você pensou a partir do requisito, sem copiar da proposta
- Rode os testes você mesmo e faça um commit com uma mensagem que diga o porquê