<\> Casa do Dev
Notícias abrir
Ferramentas abrir
Vagas abrir
Aprender abrir
Comunidade abrir
Guia de Compras abrir

Estagiário na era do Claude Code: como aprender quando a IA faz o grosso

DA

11 min

Estagiário na era do Claude Code: como aprender quando a IA faz o grosso

O estagiário que imprime a task e pede para o agente executar sente que não aprende; o guia transforma o fluxo IA-first em aprendizado real, com o conselho de quem tem 16 anos de carreira.

Neste artigo

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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 relatoFluxo que ensina
Imprime a task e cola para o agenteLê a task no sistema com contexto e comentários
Agente executa a task inteiraExecução em partes pequenas, uma por vez
Aceita o resultado porque entendeu o resumoLê o diff linha a linha e questiona cada escolha
Abre o PR e segue para a próximaReescreve um trecho, compara e anota o aprendizado
Depuração só quando o revisor devolveTestes 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.

Produtos relacionados

Este conteúdo tem links de afiliado: se você comprar por eles, podemos receber uma comissão sem custo extra para você. A escolha dos produtos segue critérios próprios e não é influenciada por comissão.

O que você achou deste artigo?

Responda a Pergunta do Dia Teste seu conhecimento e mantenha sua streak. Crie seu Dev Card público Perfil dev compartilhável em um único link.

Vagas relacionadas

Ver todas as vagas →
DA

Escrito por

Dagmar

Publicado em

Ver perfil do autor

COMPARTILHAR