Neste artigo
- Por que essa fase da carreira é diferente das outras
- O consenso dos experientes nos comentários
- A voz dos 16 anos de casa
- Um fluxo IA-first que ensina de verdade
- Os sinais de que você está aprendendo, não só entregando
- É normal o estagiário se sentir assim usando IA?
- Devo codar na mão se a empresa deixa usar IA?
- Como usar Claude Code sem virar espectador?
- O que fazer quando o revisor critica um PR gerado por IA?
- A síndrome do impostor no estágio passa?
Uma das discussões mais reveladoras da semana no r/programacao veio de quem acabou de entrar no mercado. Um estagiário publicou o relato do primeiro emprego numa empresa de desenvolvimento: o time passa as tarefas pelo quadro Kanban, entrega um notebook com Claude Code configurado e deixa o estreante se virar. O fluxo que ele descreve é simples de contar e desconfortável de ouvir: ele imprime a task, pede para o agente consultar o código do projeto e executar o que o print exige, com a documentação aberta ao lado. Ele entende o que a ferramenta produz, mas sente síndrome do impostor, porque o próprio trabalho, nas palavras dele, se resume a imprimir a task e dizer faça.
O relato do estágio com Claude Code tocou um nervo exposto do momento: a primeira fase da carreira agora acontece num ambiente em que a máquina escreve a maior parte do código, e ninguém preparou o estreante para descobrir o que ele deve aprender quando o grosso do trabalho já vem pronto. Este guia organiza o consenso que os mais experientes deixaram nos comentários da thread e o transforma em fluxo prático.
Por que essa fase da carreira é diferente das outras
Antes das recomendações, o princípio que as sustenta. A thread da mesma semana que defende que codar na mão ainda é extremamente importante parte de um argumento que encaixa perfeitamente no caso do estagiário: a prática deliberada de qualquer ação é o que leva a ficar bom nela. Programar não é só produzir código; é construir repertório de leitura, depuração, modelagem e conserto de erro. Esse repertório se deposita quando você escreve, quebra, lê a mensagem de erro e conserta.
O código gerado pela IA que você apenas aprova não deposita esse repertório, do mesmo jeito que assistir a alguém treinar não constrói músculo. Para o pleno e o sênior, delegar acelera porque o repertório já existe e a revisão é barata. Para quem está no estágio, o estoque de coisas a dominar está no início da fila, e delegar tudo nesse momento é desperdiçar o único período da carreira em que a organização espera, e até paga, para você errar devagar e aprender no processo. É por isso que o desconforto relatado pelo estagiário importa: ele percebeu sozinho que existe uma diferença entre entender o resultado e saber produzir.
ℹ️ Info: síndrome do impostor é a sensação persistente de que você não merece o lugar que ocupa, mesmo com evidências contrárias. No estágio com uso alto de IA, ela tem um componente objetivo: se você não escreveu o código, não construiu a confiança que sustenta o cargo. A solução é construir o repertório que falta, não se convencer de que ele existe.
O consenso dos experientes nos comentários
As respostas dos profissionais mais rodados na thread convergiram em três movimentos, que juntos formam uma postura para o estágio na era dos agentes:
1. Fazer na mão e deixar o erro acontecer nessa fase. O consenso começa por aqui: no estágio, o valor que você entrega para o time não é o volume de código, é a construção da sua capacidade. Errar é o mecanismo do aprendizado, e o estágio é o lugar mais barato da carreira para errar, porque ninguém espera do estagiário a velocidade nem a precisão do pleno. Escrever a primeira versão, errar, depurar e consertar rende o repertório que a IA não deposita.
2. Conectar o agente às tarefas em vez de imprimir. O segundo ponto corrige o detalhe mais mecânico do relato: imprimir a task e colar o print para o agente corta o estreante fora do fluxo real de engenharia. A recomendação dos experientes é conectar a ferramenta à fonte: apontar o agente ao repositório e ao sistema de tarefas, ler a task no próprio contexto, com histórico e comentários, e escrever o pedido a partir disso. O fluxo que sobra é o que o estágio deveria ensinar: entender o ticket, planejar, produzir em partes pequenas, abrir pull request e passar pela revisão.
3. Transformar cada PR gerado em estudo. Quando a IA gera o código mesmo assim, o material não se perde: o pull request vira objeto de estudo. Ler o diff linha a linha, perguntar por que cada linha existe, investigar o que aconteceria sem ela, reescrever um trecho por conta própria e comparar. O código gerado deixa de ser entrega pronta e vira material de leitura, e é a leitura atenta que converte produção da máquina em aprendizado seu.
A voz dos 16 anos de casa
Entre os comentários da thread, o que resume o momento veio de um engenheiro com 16 anos de carreira: o trabalho dele hoje virou revisar, mas aprender continua manual. A frase condensa a assimetria da fase. A senioridade dele se apoiou em anos de código escrito, depurado e consertado, e é esse acervo que permite revisar rápido o que os agentes produzem, porque quem já viu mil erros reconhece o padrão no primeiro olhar.
Para o estagiário, a conta é invertida. Revisar exige repertório, e repertório é exatamente o que a fase inicial ainda não construiu. Aceitar tudo sem conseguir conferir não é revisão, é aprovação às cegas com assinatura de responsável. Quando o revisor do time pergunta por que uma linha está ali, quem só apertou o botão não tem resposta, e a resposta ausente aparece justamente na hora que decide a reputação de alguém que está começando. A conclusão do experiente é o oposto do que o fluxo do relato sugere: quanto mais a IA faz o grosso, mais manual precisa ser o aprendizado de quem está no início.
Um fluxo IA-first que ensina de verdade
Rejeitar a IA no estágio não é opção, e não é isso que os comentários recomendam. A empresa forneceu a ferramenta e o fluxo dela é esse. O que dá para mudar é a posição do estagiário dentro do fluxo. Um caminho que mantém o uso da ferramenta e devolve o aprendizado para o centro:
- Leia a task no sistema, nunca no print. Contexto, critério de pronto, comentários de quem pediu e anexos fazem parte do trabalho. O print é a versão empobrecida da tarefa.
- Escreva o plano antes de pedir. Quais arquivos você tocaria, qual a ordem, onde estão os riscos. Se você não consegue esboçar o plano, a lacuna está aí, e descobri-la antes vale mais que o PR.
- Peça em partes pequenas e aceite pouco. Um método por vez, com explicação do agente junto. Quanto menor o pedaço, mais fundo você consegue ler.
- Leia o diff linha a linha como se fosse prova. Cada linha precisa ter uma resposta para a pergunta por que existe. Linha sem resposta é anotação de estudo para o dia.
- Reescreva um trecho por conta própria e compare. A diferença entre a sua versão e a do agente é o material de estudo mais denso que existe, porque expõe decisões.
- Rode os testes e quebre de propósito uma vez. Altere algo para ver o erro acontecer, leia a mensagem e conserte. É o ciclo de depuração que forma o repertório.
- Anote uma coisa nova por PR. Um conceito, um padrão, um comando. Em semanas, o caderno vira o mapa do que você aprendeu de fato.
| Fluxo do relato | Fluxo que ensina |
|---|---|
| Imprime a task e cola para o agente | Lê a task no sistema com contexto e comentários |
| Agente executa a task inteira | Execução em partes pequenas, uma por vez |
| Aceita o resultado porque entendeu o resumo | Lê o diff linha a linha e questiona cada escolha |
| Abre o PR e segue para a próxima | Reescreve um trecho, compara e anota o aprendizado |
| Depuração só quando o revisor devolve | Testes rodados e um erro provocado por tarefa |
A diferença entre as colunas não está na ferramenta, está em quem toma as decisões. O passo do vibe coding ao harness engineering descreve essa mesma fronteira em escala de indústria: times maduros não abriram mão dos agentes, mudaram quem define o corredor em que eles executam.
⚠️ Atenção: a velocidade da IA esconde uma troca conhecida: código chega mais rápido, depuração fica mais difícil. Para quem está começando, o efeito é multiplicado, porque depurar exige repertório que a fase ainda não deu tempo de construir. O alerta está detalhado no estudo sobre produtividade com IA e depuração, e vale como régua: só delegue o que você conseguiria depurar sozinho.
Os sinais de que você está aprendendo, não só entregando
Para acompanhar o próprio progresso nessa fase, quatro sinais práticos, checáveis a cada semana:
- Você explica cada linha de um PR aprovado sem abrir a conversa com o agente.
- Você previu um problema no código gerado antes de rodar, e estava certo.
- Você já corrigiu o agente quando ele tomou o caminho errado, e soube dizer por que o caminho certo é melhor.
- Você concluiu do início ao fim, sem gerar código, pelo menos uma tarefa pequena.
Quatro sinais ativos significam que o fluxo está te formando. Um ou nenhum significa que você virou operador de botão, e a correção é voltar ao primeiro passo do fluxo: ler, planejar, escrever, errar. O guia de uso de IA no dia a dia da programação detalha como equilibrar delegação e domínio nas outras fases da carreira, e a leitura sobre como o Jules e o vibe coding estão transformando a programação mostra para onde esse fluxo caminha quando o estreante de hoje virar o pleno de amanhã.
💡 Dica: transforme o revisor do time em professor. Depois de cada PR, pergunte o que ele mudaria e por quê. A resposta vale mais que qualquer material de estudo, porque vem do código real da empresa e do olhar de quem já consertou aquele sistema antes. Nenhum experiente reclama de estagiário que pergunta com o diff aberto na tela.
Perguntas frequentes
É normal o estagiário se sentir assim usando IA?
Sim, e o relato do r/programacao mostra que a sensação tem base real: quem aprova código que não escreveu não constrói a confiança que o cargo pede. O desconforto é sinal de consciência profissional, e o caminho é transformá-lo em método de estudo sobre o que a IA produz.
Devo codar na mão se a empresa deixa usar IA?
No estágio, sim, pelo menos em parte do trabalho. O consenso dos experientes na thread é que a fase inicial é o momento de construir repertório, e repertório vem de escrever, errar e depurar. Delegue o que domina, escreva o que está aprendendo, e use o código gerado como material de leitura.
Como usar Claude Code sem virar espectador?
Conecte o agente ao repositório e ao sistema de tarefas em vez de imprimir prints, peça execução em partes pequenas, leia o diff linha a linha, reescreva um trecho por conta própria e rode os testes com um erro provocado. O fluxo completo está na seção acima.
O que fazer quando o revisor critica um PR gerado por IA?
Entenda a crítica como diagnóstico seu, não do código: se você não consegue defender a escolha questionada, é sinal de que a leitura linha a linha ficou faltando. Corrija, volte ao diff, e leve a dúvida ao revisor com pergunta específica. Critica recebida com método vira aprendizado registrado.
A síndrome do impostor no estágio passa?
Passa com repertório, não com autoajuda. Cada erro depurado, cada diff lido e cada tarefa concluída do início ao fim substitui a dúvida por evidência. A sensação é o sistema de alarme apontando exatamente onde investir o esforço da fase.