O Código Chegou Pronto, e Agora? Um Roteiro Básico para Testar o que a IA Escreveu Antes de Confiar Nele
Você pede para a IA implementar uma função de validação de CPF. Ela responde em segundos, o código parece limpo, tem até comentários explicando cada etapa. Você copia, cola no projeto, roda uma vez com um CPF de teste, funciona, e segue para a próxima tarefa. Duas semanas depois, um cliente reporta que o sistema aceitou um CPF inválido no cadastro. Você abre o código, olha para aquela função “pronta” e percebe que ela nunca validou o cálculo dos dígitos verificadores de verdade — apenas checava se a string tinha onze caracteres numéricos.
Essa cena se repete todos os dias em equipes de desenvolvimento que adotaram assistentes de IA como Claude Code, GitHub Copilot ou ChatGPT. O problema não é a IA escrever código ruim — na maioria das vezes ela escreve código plausível, bem formatado e com aparência de correto. O problema é que “parecer correto” e “estar correto” são coisas diferentes, e sem um processo de validação, o desenvolvedor só descobre a diferença quando o erro já causou dano.
Este artigo apresenta, do zero, um roteiro básico para você testar e validar qualquer código gerado por IA antes de integrá-lo ao seu projeto. Vamos explicar cada conceito, mostrar exemplos de código completos e funcionais, e construir junto um checklist que você pode aplicar já na próxima tarefa.
Por que código gerado por IA exige um cuidado diferente
Quando um colega de equipe escreve código, você tem um contexto implícito: sabe o nível de experiência dele, sabe se ele testou localmente, pode perguntar “por que você fez assim?” e receber uma resposta fundamentada. Com a IA, esse contexto não existe da mesma forma. O modelo gera a resposta mais provável estatisticamente para o seu pedido, não necessariamente a mais correta para o seu caso específico.
Segundo o guia da GitLab sobre geração de código com IA, os desenvolvedores devem trabalhar em conjunto com os sistemas de IA para validar o código gerado, apresentar contexto adicional e requisitos, em vez de simplesmente aceitar a primeira resposta como definitiva. Essa ideia é o ponto central deste artigo: a IA é uma colaboradora que precisa de revisão, não uma fonte de verdade.
💡 Dica do Mestre: Existe até discussão sobre se é possível identificar que um trecho de código foi escrito por IA. Uma thread da comunidade r/learnpython no Reddit discute exatamente isso, e ferramentas como o detector de código de IA da Pangram tentam automatizar essa identificação. Mas isso é uma curiosidade lateral: o que realmente importa para você, desenvolvedor, não é saber quem escreveu o código, e sim se ele funciona corretamente.
O primeiro passo: leia o código antes de rodar
Antes de qualquer teste automatizado, existe uma etapa manual e obrigatória: a leitura crítica. Muitos desenvolvedores pulam essa etapa porque o código “parece certo” à primeira vista. Mas ler o código com atenção é o que revela decisões escondidas, como usar uma biblioteca desatualizada, ignorar um caso de borda ou simplificar demais uma regra de negócio.
Vamos usar um exemplo simples em Python. Suponha que você pediu à IA uma função para calcular o desconto de um pedido:
|
1 2 3 4 5 6 7 |
def calcular_desconto(valor_total, quantidade_itens): if quantidade_itens > 10: return valor_total * 0.9 return valor_total |
À primeira vista, parece razoável: pedidos com mais de dez itens recebem 10% de desconto. Mas ao ler com atenção, surgem perguntas que só um humano que conhece o negócio consegue responder: e se valor_total for negativo? E se quantidade_itens for zero ou negativo? O desconto deveria ser aplicado apenas sobre parte do valor, ou sobre o total? Essas perguntas não aparecem no código — elas aparecem na sua cabeça, durante a leitura crítica.
Perguntas que você deve se fazer ao ler código de IA
- Esse código trata valores nulos, vazios ou negativos?
- As mensagens de erro fazem sentido para quem vai depurar isso depois?
- A biblioteca ou função usada ainda é a recomendada, ou está obsoleta?
- Essa lógica reflete exatamente a regra de negócio que eu pedi, ou é uma versão simplificada?
- Existe algum caso de borda óbvio que não foi tratado?
O segundo passo: escreva testes automatizados para o código gerado
Ler o código ajuda a levantar suspeitas, mas testes automatizados confirmam ou refutam essas suspeitas com evidência concreta. Um teste automatizado é um trecho de código que executa outro trecho de código e verifica se o resultado é o esperado, sem que você precise repetir esse processo manualmente toda vez.
Continuando o exemplo anterior, vamos escrever testes usando a biblioteca padrão de testes do Python, o unittest — mas se você preferir, o mesmo raciocínio vale para pytest, Jest, JUnit ou qualquer framework de testes da sua linguagem.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
import unittest def calcular_desconto(valor_total, quantidade_itens): if quantidade_itens > 10: return valor_total * 0.9 return valor_total class TestCalcularDesconto(unittest.TestCase): def test_sem_desconto_com_poucos_itens(self): resultado = calcular_desconto(100, 5) self.assertEqual(resultado, 100) def test_desconto_aplicado_com_muitos_itens(self): resultado = calcular_desconto(100, 11) self.assertEqual(resultado, 90) def test_valor_total_negativo_deveria_ser_rejeitado(self): with self.assertRaises(ValueError): calcular_desconto(-50, 15) def test_quantidade_zero_nao_gera_erro(self): resultado = calcular_desconto(100, 0) self.assertEqual(resultado, 100) if __name__ == "__main__": unittest.main() |
Ao rodar esses testes, o terceiro caso — test_valor_total_negativo_deveria_ser_rejeitado — vai falhar, porque a função original da IA não lança nenhuma exceção para valores negativos. Isso é exatamente o ponto: o teste automatizado transformou uma suspeita (“será que isso trata valores negativos?”) em um fato verificável (“não trata, e aqui está a prova”).
Com essa evidência em mãos, você corrige a função — sozinho ou pedindo à própria IA que ajuste, agora com o requisito explícito:
|
1 2 3 4 5 6 7 |
def calcular_desconto(valor_total, quantidade_itens): if valor_total 10: return valor_total * 0.9 return valor_total |
Rodando os testes novamente, todos passam. Esse ciclo — escrever teste, rodar, corrigir, rodar de novo — é a base de qualquer processo de validação sério, e funciona da mesma forma seja o código escrito por você, por um colega ou por uma IA.
O terceiro passo: teste os casos de borda, não apenas o caminho feliz
Um erro comum de quem está começando é testar apenas o “caminho feliz” — o cenário em que tudo dá certo. Mas a maioria dos bugs em produção acontece nos casos de borda: entradas vazias, valores extremos, tipos inesperados, condições de rede instáveis.
Vamos ilustrar isso com um exemplo em JavaScript, uma função que a IA poderia gerar para validar um e-mail:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
function validarEmail(email) { const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; return regex.test(email); } // Testes manuais rápidos no console console.log(validarEmail("adriano@exemplo.com")); // true console.log(validarEmail("email-invalido")); // false console.log(validarEmail("")); // false console.log(validarEmail(null)); // ERRO: Cannot read properties of null |
Perceba que os três primeiros casos funcionam bem, e é fácil parar por aí, satisfeito com o resultado. Mas o quarto caso — passar null como argumento — quebra a aplicação inteira com um erro não tratado. Se essa função receber dados de um formulário onde o campo de e-mail pode chegar vazio ou nulo, o sistema vai falhar silenciosamente ou, pior, derrubar a aplicação inteira.
A correção é simples, mas só aparece quando você pensa deliberadamente nos casos de borda:
|
1 2 3 4 5 6 7 8 9 10 |
function validarEmail(email) { if (typeof email !== "string" || email.trim() === "") { return false; } const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; return regex.test(email); } |
Uma checklist prática de casos de borda
- Entrada vazia (string vazia, lista vazia, objeto vazio)
- Entrada nula ou indefinida
- Valores numéricos extremos (zero, negativos, muito grandes)
- Caracteres especiais ou acentuação em textos
- Concorrência: o que acontece se a função for chamada duas vezes ao mesmo tempo?
O quarto passo: valide o comportamento, não apenas a sintaxe
Código gerado por IA quase sempre compila, roda e não gera erro de sintaxe — afinal, o modelo foi treinado com enormes volumes de código sintaticamente correto. O problema real está no comportamento: a lógica de negócio implementada é a lógica que você realmente precisa?
Para validar comportamento, é útil escrever os testes antes de pedir o código à IA, ou logo em seguida, descrevendo em termos concretos o que o sistema deveria fazer. Essa prática se aproxima do conceito de especificação antes da implementação, algo que já discutimos aqui no blog em outro artigo sobre desenvolvimento orientado por especificação, e que se aplica muito bem à validação de código de IA: você define o comportamento esperado em forma de teste, e só depois confirma se a implementação atende a esse contrato.
Veja um exemplo em Delphi, útil para quem trabalha com sistemas legados ou aplicações desktop, mostrando como validar o comportamento de uma função que a IA poderia ter sugerido para calcular juros simples:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
function CalcularJurosSimples(Capital, Taxa: Double; Periodo: Integer): Double; begin Result := Capital * (Taxa / 100) * Periodo; end; // Teste usando DUnit ou DUnitX procedure TestCalcularJurosSimples; begin Assert(CalcularJurosSimples(1000, 5, 12) = 600, 'Juros de 5% ao mês sobre 1000 por 12 meses deveria ser 600'); Assert(CalcularJurosSimples(0, 5, 12) = 0, 'Capital zero deveria gerar juros zero'); end; |
Rodar esse teste confirma se a fórmula implementada corresponde à fórmula financeira correta de juros simples. Sem esse teste, a única forma de descobrir um erro na fórmula seria um relatório financeiro incorreto chegando às mãos de um cliente — um custo muito mais alto do que alguns segundos rodando um teste automatizado.
O quinto passo: use ferramentas de teste que já existem, não reinvente tudo
Você não precisa construir sua própria infraestrutura de testes do zero. Existem ferramentas maduras, algumas delas já incorporando inteligência artificial para gerar e validar testes automaticamente. O material da TestSprite sobre testes de ponta a ponta com IA lista opções como Testim, Functionize, Katalon e Applitools, voltadas justamente para validar aplicações inteiras, incluindo código gerado por IA, de forma automatizada.
💡 Dica do Mestre: Se você está começando agora, não precisa adotar essas ferramentas de teste de ponta a ponta imediatamente. Comece pelo básico: testes unitários simples, como os exemplos deste artigo, usando o framework de testes nativo da sua linguagem. Ferramentas mais sofisticadas fazem sentido quando o projeto cresce e o volume de cenários a testar manualmente se torna inviável.
Vale destacar também que essa preocupação não é exclusiva de quem escreve código sozinho. Em um vídeo sobre o ritmo acelerado da geração de código por IA, disponível no canal do YouTube sobre IA e testes de software, é discutida a ideia de manter uma biblioteca de validação própria, reutilizável entre projetos, exatamente para não depender de testar tudo manualmente toda vez que a IA gera um novo trecho de código.
Montando seu checklist básico de validação
Reunindo tudo o que vimos até aqui, este é um checklist simples que você pode aplicar sempre que a IA gerar código para o seu projeto:
- Leia antes de rodar: identifique decisões implícitas, bibliotecas usadas e possíveis simplificações indevidas.
- Escreva testes automatizados: pelo menos um teste para o caminho feliz e um para cada caso de borda óbvio.
- Teste valores extremos: nulo, vazio, negativo, zero, muito grande.
- Confirme o comportamento contra a regra de negócio real, não apenas contra a sintaxe.
- Rode os testes de regressão existentes no projeto, para garantir que o novo código não quebrou nada que já funcionava.
- Documente o motivo de qualquer ajuste feito no código gerado, para que o próximo desenvolvedor (ou a próxima sessão de IA) entenda o contexto.
Convite para aprofundar o assunto
Validar código gerado por IA é uma habilidade que se desenvolve com prática e com troca de experiências reais entre desenvolvedores que enfrentam os mesmos desafios todos os dias. Se você quer discutir casos concretos, compartilhar scripts de teste e aprender com quem já passou por situações parecidas com as deste artigo, participe da Comunidade Dev’s AI. É um espaço para quem desenvolve software no dia a dia e quer usar IA de forma responsável, sem abrir mão da qualidade.
Conclusão
A inteligência artificial mudou a velocidade com que o código é escrito, mas não mudou a responsabilidade de quem assina o commit. Um código gerado em segundos pode economizar horas de trabalho, ou pode custar dias de correção em produção — a diferença está inteiramente no processo de validação que você aplica antes de integrá-lo ao projeto.
Comece pelo básico: leia com atenção, escreva testes automatizados simples, pense nos casos de borda e confirme se o comportamento implementado é realmente o comportamento que você precisa. Esse hábito, praticado de forma consistente, transforma a IA de uma fonte de risco silencioso em uma ferramenta genuinamente produtiva — exatamente o papel que ela deveria cumprir no seu fluxo de trabalho.