Estamos treinando nossa própria substituição (e ninguém tem um plano B)

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