Semana passada passei três horas debugando um bug que o Copilot gerou. Não foi a primeira vez. E provavelmente não será a última. O que me fez pensar: estamos mesmo construindo ferramentas para nos substituir, ou apenas mudando o tipo de problema que resolvemos?

A promessa que não chegou

Lembra de 2022? GPT-3 saindo, todo mundo dizendo que programadores iam virar "prompt engineers" e que código ia sumir. Três anos depois, continuo escrevendo código. Muito código. Só que agora também corrijo o que a IA gera.

A verdade é que IA não está nos substituindo — está redistribuindo nosso tempo. Menos tempo escrevendo boilerplate, mais tempo fazendo code review de máquina. Menos tempo no Stack Overflow, mais tempo refinando prompts. O trabalho mudou, não sumiu.

O que realmente acontece no código

Vou te mostrar um exemplo real. Pedi para o GPT-4 gerar um hook React para debounce de busca:

// O que o GPT-4 gerou function useDebounce(value, delay) { const [debouncedValue, setDebouncedValue] = useState(value); useEffect(() => { const handler = setTimeout(() => { setDebouncedValue(value); }, delay); return () => { clearTimeout(handler); }; }, [value, delay]); return debouncedValue; }

Funciona. Até funciona bem para 80% dos casos. O problema está nos 20% que a IA não vê:

// O que você realmente precisa em produção function useDebounce(value, delay, options = {}) { const [debouncedValue, setDebouncedValue] = useState(value); const { leading = false, maxWait } = options; useEffect(() => { if (leading && !maxWait) { setDebouncedValue(value); } const handler = setTimeout(() => { setDebouncedValue(value); }, delay); const maxHandler = maxWait ? setTimeout(() => { setDebouncedValue(value); }, maxWait) : null; return () => { clearTimeout(handler); if (maxHandler) clearTimeout(maxHandler); }; }, [value, delay, leading, maxWait]); return debouncedValue; }

Isso você não consegue com um prompt simples. Você precisa saber que existe leading, que pode precisar de maxWait, que há edge cases em formulários complexos. A IA gera código que compila — você adiciona código que sobrevive em produção.

O jogo mudou, não acabou

Converso com desenvolvedores sênior e a história se repete: ninguém foi substituído, mas todo mundo mudou de função. O junior que antes copiava do Stack Overflow agora copia do ChatGPT (e continua não entendendo closure). O pleno que antes escrevia CRUD manualmente agora revisa CRUD gerado. O sênior que antes arquitetava sistemas agora também valida se a arquitetura sugerida pela IA faz sentido no contexto real.

Três habilidades que cresceram em importância:

1. Code review virou skill primária

Antes você revisava código de humanos duas vezes por semana. Agora revisa código de IA vinte vezes por dia. E código de IA é traiçoeiro — parece certo, tem a estrutura certa, usa os padrões certos, mas tem sutilezas erradas.

// IA adora gerar isso const data = await fetch('/api/users') .then(res => res.json()) .catch(err => console.error(err)); // Mas você precisa disso const data = await fetch('/api/users') .then(res => { if (!res.ok) throw new Error(`HTTP ${res.status}`); return res.json(); }) .catch(err => { logger.error('Failed to fetch users', { error: err }); throw err; // re-throw ou trate, não engula });

A IA não sabe que seu logger customizado existe. Não sabe que você trata 4xx diferente de 5xx. Não sabe que console.error não chega no seu monitoring. Você sabe.

2. Context é o novo código

Quanto melhor você documenta intenção, requisitos, constraints, melhor a IA performa. Aprendi a escrever comentários melhores não para humanos, mas para aumentar a chance da IA gerar algo útil:

/** * Busca usuários com debounce de 300ms. * * CONSTRAINTS: * - Não fazer request se query < 3 chars * - Cancelar requests pendentes (AbortController) * - Logar falhas no Sentry, não no console * - Retornar [] em caso de erro, nunca null * * CONTEXT: usado em autocomplete, usuário pode digitar rápido, * API tem rate limit de 10 req/s por IP. */

Isso não é documentação — é prompt engineering disfarçado de comentário.

3. Conhecer limites da ferramenta

IA é ótima para: boilerplate, conversão de formato, testes unitários simples, refatoração mecânica.

IA é péssima para: decisões de arquitetura, trade-offs de performance, integrações complexas, qualquer coisa que dependa de context não-escrito.

Saber quando usar é mais importante que saber usar.

O que não te contam

Três verdades inconvenientes que descobri trabalhando com IA no dia a dia:

Débito técnico gerado por IA é mais difícil de pagar. Quando você escreve código ruim, você sabe onde está ruim. Quando a IA gera código "quase certo", você demora mais para achar o problema porque parece profissional.

IA padroniza para a mediana. Todo código gerado parece código de tutorial. Isso é ótimo para começar, terrível para escalar. Você acaba com 50 arquivos que seguem o mesmo padrão genérico, quando seu caso de uso pedia algo específico.

O custo cognitivo não sumiu, mudou de lugar. Antes: pensar em como escrever o código. Agora: pensar em como descrever o que você quer, validar se o que veio é o que você pediu, debugar quando não é. Diferente, não mais fácil.

Então qual é o plano?

Se você está começando agora: aprenda a programar de verdade antes de usar IA como muleta. Você precisa ser capaz de ler o código que a máquina gera e saber se está certo. Isso exige base.

Se você já programa: invista em habilidades que IA não replica fácil. Entender o domínio do negócio. Comunicação com stakeholders. Debugging de sistemas distribuídos. Arquitetura de longo prazo. Code review criterioso.

Se você lidera: repense suas contratações. Junior que só sabe usar Copilot não é junior, é risco. Sênior que ignora IA também é risco. Procure quem entende código E sabe usar ferramentas.

TL;DR

  • IA não está substituindo desenvolvedores, está mudando o tipo de trabalho que fazemos
  • Código gerado por IA funciona, mas raramente está pronto para produção sem ajustes
  • Code review virou habilidade primária — você revisa máquina mais que humano
  • Contexto e documentação viraram ferramentas de produtividade (são prompts disfarçados)
  • Débito técnico de IA é mais traiçoeiro que débito humano
  • O plano: aprender fundamentos, dominar code review, focar em skills que IA não replica