A IA quebrou o pipeline de devs juniores (e ninguém tá falando disso)

Nos últimos dois anos, vi três empresas brasileiras congelarem contratações de júnior. Não por crise — os times seniors estavam contratando. O motivo? "Com Copilot, um pleno faz o trabalho de dois juniores." Parece eficiência. Mas se você parar pra pensar cinco minutos, percebe que acabamos de serrar o galho onde a gente tá sentado.

O problema não é a ferramenta, é o modelo mental

A IA de fato multiplica produtividade de quem já sabe o que tá fazendo. Um senior com ChatGPT escreve testes mais rápido, scaffolding vira commodity, refactor massivo acontece em minutos. Mas o pulo do gato é justamente esse "já sabe o que tá fazendo".

Um júnior não sabe. E as tasks que ele fazia pra aprender — ajustes de CSS, bugs óbvios de lógica, escrever CRUD pela décima vez até virar músculo — agora são delegadas pra IA. O problema: essas tasks chatas eram o tutorial do mundo real.

O que a gente perdeu no caminho

Quando eu comecei (2018, React 16 era novidade), passei seis meses só fazendo forms. Parecia perder tempo. Mas foi ali que internalizei:

• Estado local vs global
• Side effects (aprendi useEffect errando, não lendo doc)
• Como lidar com async sem travar a UI
• Performance (renderizações desnecessárias doem quando você causa elas)

// Meu primeiro form "de verdade" — parece simples, mas tinha// que entender controlled components, validação, submit assíncronofunctionLoginForm(){const[email,setEmail]=useState('');const[loading,setLoading]=useState(false);consthandleSubmit=async (e)=>{e.preventDefault();setLoading(true);try{awaitapi.login({email});// Como lidar com sucesso? Redirect? Toast? Context?// Essas perguntas só aparecem quando você tá fazendo.}catch (err){// E erro? Mostrar onde? Como?}finally{setLoading(false);}};return (<formonSubmit={handleSubmit}><inputvalue={email}onChange={e=>setEmail(e.target.value)}disabled={loading}/><buttondisabled={loading}>{loading?'Carregando...':'Entrar'}</button></form>);}

Hoje, um júnior pede pro Copilot e recebe isso pronto. Ele comita. Funciona. Mas ele não sabe por que funciona. E quando quebra em produção (loading state não reseta após erro de rede), ele não tem o mapa mental pra debugar.

O que acontece quando pulamos o tutorial

Conheci um dev recém-formado que usava IA pra tudo. Brilhante, rápido, entregava. Até o dia que o Copilot sugeriu um useEffect sem array de dependências. Ele aceitou. O componente entrou em loop infinito. Ele não entendia por quê — afinal, "a IA sempre funciona".

// Copilot sugeriu isso (e tá sintaticamente correto!)functionUserProfile({userId}){const[user,setUser]=useState(null);useEffect(()=>{fetchUser(userId).then(setUser);// ⚠️ Falta o array de dependências. Isso dispara a cada render.// Que causa um setUser. Que causa outro render. Loop infinito.});return<div>{user?.name}</div>;}

Um pleno vê isso e corrige no code review. Mas se você nunca causou esse bug sozinho, nunca debugou um componente travando o browser, você não desenvolve o reflexo. Vira conhecimento teórico, não operacional.

A ilusão da senioridade precoce

A IA cria uma falsa sensação de domínio. Você entrega código que parece profissional porque a IA escreve bem. Mas quando precisa:

• Decidir entre Context API, Zustand ou Redux (a IA gera qualquer um)
• Otimizar um re-render pesado (a IA mostra useMemo, mas onde?)
• Arquitetar um sistema novo (a IA segue padrões genéricos, não o seu contexto)

...você empaca. Porque essas decisões exigem ter errado antes. Ter escolhido Context pra tudo e visto o app virar spaghetti. Ter esquecido useMemo e visto a lista de 10k itens travar.

O que fazer? (spoiler: não é "parar de usar IA")

Três coisas que tenho visto funcionar:

1. Code review como mentoria explícita

Não aceite "funciona" como métrica. Pergunte: "Por que você usou useCallback aqui? O que acontece se tirar?" Se a resposta for "o Copilot sugeriu", é red flag. O júnior precisa re-implementar do zero pra entender.

2. Tasks intencionalmente sem IA

Reserve bugs pequenos e peça: "resolve sem IA, manda perguntas no Slack". Parece cruel. Mas é nesses 40 minutos debugando um undefined que você internaliza como runtime funciona.

3. Pair programming assíncrono

Grave sua tela enquanto codifica. Mostra o processo: como você lê a stack trace, que log você adiciona, por que testou aquele edge case. Júnior copia o processo, não só o código.

# Exemplo: meu flow de debug que eu gravo e compartilho# 1. Reproduzir o bug localmente
npm run dev
# abrir devtools, Network tab# 2. Adicionar logs estratégicos (não console.log aleatório)
// antes do fetch
console.log('fetchUser called with:', userId);
// depois do fetch
console.log('fetchUser returned:', data);# 3. Ver o que tá diferente do esperado# 4. Formar hipótese ("tá chamando duas vezes?")# 5. Validar hipótese (adicionar breakpoint)# 6. Fixar

Esse flow não sai de prompt do ChatGPT. Vem de repetição.

O elefante na sala: vagas

A parte incômoda: empresas de fato precisam de menos juniores agora. Mas se todo mundo parar de contratar, de onde vêm os seniors de 2030? Não existe dev senior que não foi júnior antes.

A solução não é romantizar sofrimento ("na minha época fazíamos tudo na mão"). É reconhecer que aprender a programar é diferente de aprender a usar ferramentas. A IA é uma ferramenta absurda. Mas se você nunca aprendeu a programar sem ela, você não programa — você delega.

TL;DR

• IA multiplica produtividade de quem já sabe; não ensina quem não sabe.
• Tasks "chatas" de júnior eram o tutorial do mundo real — e sumiram.
• Copilot gera código correto, mas não te ensina por que tá correto.
• Sem os bugs de júnior, você não desenvolve reflexos de debug.
• Solução: code review educativo, tasks sem IA, pair programming gravado.
• Se ninguém treina júnior, de onde vêm os seniors de amanhã?