A IA Gerou Código Quebrado e Eu Só Descobri Depois — Como Não Cair Nessa Armadilha

PorOlivetto

Olha, eu vou ser completamente honesto com você: aconteceu comigo ontem. E se aconteceu comigo, que passo 12 horas por dia mexendo com tecnologia, pode acontecer com qualquer um.

Estava montando um script de automação para processar dados de um cliente. Pedi para a IA gerar o código em Python. Ela entregou algo que parecia perfeito: estruturado, comentado, usando as bibliotecas certas. Rodei os testes unitários — tudo passou. Fiz o deploy. Fui dormir feliz.

Acordei com 47 mensagens no WhatsApp do cliente. O script tinha processado 15 mil registros e corrompido metade deles. O problema? A IA tinha usado uma função de encoding que funcionava perfeitamente para caracteres ASCII, mas quebrava completamente quando encontrava um “ç” ou um “ã”. E adivinha: o banco de dados do cliente estava cheio de nomes brasileiros.

Eu tinha confiado cegamente. E paguei o preço.

Tela de laptop quebrada com glitch colorido

Por Que a IA Gera Código “Quase Certo” (E Por Que Isso É Perigoso)

A inteligência artificial é excelente em padrões. Ela analisa milhões de linhas de código e aprende o que “parece” correto. O problema é que parecer correto não é a mesma coisa que estar correto.

Aqui está o padrão que eu vejo se repetir:

  1. Você descreve o problema para a IA
  2. Ela gera código que resolve 90% do cenário
  3. Os 10% restantes são edge cases que ela não considerou
  4. Você testa com dados perfeitos — funciona
  5. Coloca em produção — explode

No meu caso, o edge case eram caracteres especiais. Mas poderia ter sido:

  • Datas em formatos diferentes (DD/MM/AAAA vs MM/DD/AAAA)
  • Valores nulos ou vazios que quebram cálculos matemáticos
  • Arquivos maiores que a memória disponível causando crashes
  • Concorrência — dois processos acessando o mesmo arquivo simultaneamente
  • Timezone — horários em UTC vs horário local

A IA não sabe o contexto real do seu ambiente de produção. Ela não sabe que seus usuários são brasileiros, que seus arquivos têm acentos, que seu servidor tem 512MB de RAM. Ela gera código genérico e assume o melhor cenário possível.

Os 5 Erros Mais Comuns em Código Gerado por IA (E Como Evitar Cada Um)

Depois de corrigir o caos de ontem, sentei e fiz uma lista dos erros que mais vejo em código de IA. Aqui está o que aprendi:

Erro 1: Encoding de Texto (O Que Me Quebrou)

A IA geralmente assume UTF-8 e esquece de declarar encoding explicitamente. Quando seu sistema usa Latin-1, ISO-8859-1, ou qualquer outro encoding, os caracteres especiais viram lixo.

Como evitar:

  • Sempre declare o encoding: encoding='utf-8' em Python, charset=UTF-8 em HTML
  • Teste com dados reais, não apenas com exemplos limpos
  • Use bibliotecas como chardet para detectar encoding automaticamente

Erro 2: Tratamento de Erros Inexistente

Código de IA raramente inclui tratamento de erros robusto. Ele assume que:

  • O arquivo sempre existe
  • A API sempre responde
  • O banco de dados sempre está disponível
  • O usuário sempre envia dados no formato esperado

Como evitar:

  • Adicione try/except (Python), try/catch (JavaScript) em TODAS as operações externas
  • Sempre verifique se arquivos existem antes de abrir
  • Implemente retries com backoff exponencial para chamadas de API
  • Valide todos os inputs antes de processar

Erro 3: Injeção de SQL e Outras Vulnerabilidades

Este é o mais perigoso. A IA às vezes gera queries SQL concatenando strings diretamente:

# CÓDIGO INSEGURO que a IA pode gerar:
query = f"SELECT * FROM users WHERE name = '{user_input}'"

Se user_input for '; DROP TABLE users; --, você perdeu tudo.

Como evitar:

  • NUNCA concatene inputs do usuário em queries SQL
  • Use prepared statements ou ORM (SQLAlchemy, Django ORM)
  • Valide e sanitize TODOS os inputs
  • Execute ferramentas de análise de segurança (Bandit para Python, ESLint para JS)

Erro 4: Uso de Memória Ineficiente

A IA frequentemente carrega arquivos inteiros na memória:

# Problema: carrega arquivo de 2GB na RAM
with open('arquivo_gigante.csv', 'r') as f:
    dados = f.read()  # BOOM!

Como evitar:

  • Processe arquivos grandes em chunks (pedaços)
  • Use generators em vez de listas quando possível
  • Monitore o uso de memória com memory_profiler
  • Para CSVs grandes, use pandas.read_csv(chunksize=...)

Erro 5: Hardcoded Credentials e Configurações

A IA às vezes coloca senhas e chaves de API diretamente no código:

# NUNCA FAÇA ISSO
API_KEY = "sk-1234567890abcdef"
password = "minhasenha123"

Como evitar:

  • Use variáveis de ambiente: os.environ.get('API_KEY')
  • Arquivos .env com python-dotenv
  • Serviços de secrets como AWS Secrets Manager, HashiCorp Vault
  • NUNCA commite credenciais no Git (use .gitignore)

Homem frustrado olhando para laptop

Como Revisar Código de IA Como Um Profissional (Checklist Completo)

Agora que você sabe os erros comuns, aqui está o processo que eu uso para revisar código gerado por IA antes de colocar em produção:

Fase 1: Revisão Estática (5 minutos)

  1. Leia TODO o código — não apenas o que parece importante
  2. Verifique imports — a IA importa bibliotecas que você não precisa? Ou esquece alguma?
  3. Procure por “TODO” e “FIXME” — a IA às vezes deixa placeholders
  4. Verifique hardcoded values — URLs, credenciais, caminhos de arquivo
  5. Analise loops — há risco de loop infinito? Processamento O(n²) desnecessário?

Fase 2: Teste com Dados Reais (10 minutos)

  1. Use os dados MESMO do seu ambiente — não exemplos limpos
  2. Teste com inputs vazios, nulos e malformados
  3. Teste com caracteres especiais — ç, ã, é, emojis
  4. Teste com volumes grandes — 10x mais dados que o normal
  5. Teste com conexão lenta ou indisponível — desligue o WiFi no meio da execução

Fase 3: Análise de Segurança (5 minutos)

  1. Verifique se há concatenação de strings em queries
  2. Confirme que não há credenciais no código
  3. Valide todos os inputs do usuário
  4. Verifique permissões de arquivo — o script não está criando arquivos com permissão 777, né?

Fase 4: Documentação e Logging (3 minutos)

  1. Adicione logging — você precisa saber o que aconteceu quando der errado
  2. Documente o propósito de cada função
  3. Inclua exemplos de uso nos comentários

Total: 23 minutos de revisão que podem economizar horas (ou dias) de debugging depois.

Vista de cima de pessoa digitando 'BURNOUT' no laptop

O Perrengue do Olivetto: O Código Funcionava na Minha Máquina

Preciso contar um detalhe que omiti no início: o código funcionava perfeitamente no meu laptop. Todos os testes passaram. O CI/CD estava verde. Foi para produção e… boom.

A diferença? Meu laptop é Mac com filesystem APFS. O servidor de produção é Linux com ext4. A IA tinha usado uma função que criava arquivos temporários com nomes especiais. Funcionava no Mac. No Linux, quebrava silenciosamente — não dava erro, simplesmente não criava o arquivo.

Resultado: o script processava os dados, achava que tinha salvado o resultado, mas o arquivo não existia. Na próxima execução, processava tudo de novo. E de novo. E de novo. Gerou 47GB de dados duplicados antes de alguém perceber.

O que aprendi dessa vez:

  • Sempre teste no ambiente de produção — ou pelo menos no mais parecido possível (Docker ajuda muito)
  • Monitore não apenas se o código executa, mas se ele produz o resultado esperado
  • Adicione asserts e validações de saída — não apenas de entrada
  • Use staging — um ambiente intermediário entre dev e produção

E o mais importante: a IA é um acelerador, não um substituto. Ela te dá um ponto de partida excelente. Mas você ainda precisa entender o que o código faz, por que faz, e em quais condições pode falhar.

Ferramentas Que Eu Uso Para Revisar Código de IA

Depois de tantos erros, montei um toolkit de verificação:

1. Static Analysis

  • Python: pylint, flake8, black (formatador), mypy (type checking)
  • JavaScript: ESLint, Prettier
  • Geral: SonarQube, Code Climate

2. Testes

  • Unitários: pytest (Python), Jest (JS)
  • Cobertura: coverage.py, nyc
  • Fuzzing: hypothesis (Python) — gera inputs aleatórios para testar edge cases

3. Segurança

  • Python: Bandit — procura padrões inseguros
  • Geral: Snyk, GitHub Dependabot
  • Secrets: git-secrets, truffleHog

4. Performance

  • Profiling: cProfile, line_profiler
  • Memória: memory_profiler

Conclusão: A IA é uma Ferramenta, Não Uma Responsabilidade Transferida

Vou ser direto: se você copia código de IA e coloca em produção sem revisar, o problema não é a IA. É você.

A inteligência artificial é uma das ferramentas mais poderosas que já existiram para desenvolvimento. Ela pode economizar horas de trabalho, sugerir soluções que você não teria pensado, e acelerar seu aprendizado. Mas ela não é infalível. Ela não conhece seu ambiente específico. Ela não entende as consequências reais de um erro em produção.

O desenvolvedor que sabe usar IA + revisão humana vai ser 10x mais produtivo que o desenvolvedor que não usa IA. Mas o desenvolvedor que usa IA sem revisão vai ser 10x mais lento para corrigir os erros que a IA introduziu.

Escolha o primeiro caminho.

E você? Já teve algum erro bizarro causado por código de IA? Me conta nos comentários — quero saber se sou o único que já pagou esse mico. 😅

Posts Similares