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 calcularFrete e 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

  1. 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.
  2. 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.
  3. 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.
  4. Agente → Testes: npm test. O agente roda os testes do projeto para conferir o próprio trabalho.
  5. 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ê.
  6. 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.
  7. 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 é.
  8. 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 e b/ é 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 que toLocaleString faz? 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) devolve 0, como pede o requisito
  • Abaixo de R$ 100 o frete continua 12.9 e acima continua 0
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.

  1. Escreva o pedido com contexto, resultado esperado e limites, e peça um plano antes do código
  2. Ajuste o plano e aprove só o primeiro passo
  3. Leia o diff inteiro e rejeite ou ajuste pelo menos uma sugestão, anotando o motivo
  4. Acrescente um caso de teste que você pensou a partir do requisito, sem copiar da proposta
  5. Rode os testes você mesmo e faça um commit com uma mensagem que diga o porquê

Referências

Cursos relacionados