Você aprende ou desaprende programando com o Claude Code?

Fala aí, beleza? Tem uma sensação estranha rondando quem programa com agente: você entrega mais e entende menos

Aquele trecho difícil, o que antes te custava duas horas de tentativa e erro, hoje sai em trinta segundos e ainda passa no teste

Aí bate a dúvida honesta: delegar a parte complicada pro Claude Code acelera o resultado, isso ninguém discute, mas o que acontece com a SUA habilidade enquanto isso? Você está ganhando repertório de arquitetura em ritmo acelerado, ou terceirizando justo a etapa que te formava?

A boa notícia é que essa pergunta parou de ser papo de bar

Já existe ensaio randomizado, medição em repositório real e pesquisa com dev do mundo todo apontando pro mesmo lugar. Bora ver os números primeiro, e depois o jeito prático de usar o agente sem virar dependente dele

O que a pesquisa já mediu sobre programar com IA

Pré-inscrição Formação Claude Code

Domine o Claude Code do básico ao avançado

Você vai aprender a criar sistemas completos com Claude Code, sem precisar ser programador. Inscreva-se para ter acesso a um desconto de lançamento e bônus especiais!

Quero minha vaga

Começando pelo estudo mais direto ao ponto: a Anthropic rodou um ensaio randomizado controlado sobre assistência de IA e formação de habilidade

Foram 52 engenheiros de software, majoritariamente juniores, todos com pelo menos 1 ano de uso semanal de Python

Todo mundo precisou aprender a biblioteca Python Trio, que era desconhecida por todos os participantes. Um grupo codou manualmente, o outro codou com IA, e no fim vieram duas tarefas seguidas de um quiz

Resultado do quiz, sobre conceitos que a pessoa tinha ACABADO de usar: o grupo com IA acertou 17% menos que o grupo que escreveu o código à mão

Isso equivale a quase duas notas de diferença…

E tem o detalhe que dói mais: o paper aponta queda em compreensão conceitual, leitura de código e depuração, sendo a depuração o item mais afetado de todos

‘Beleza, mas pelo menos entregou mais rápido, né?’

Pois é, aqui a coisa desanda: no mesmo estudo, o ganho de produtividade do grupo com IA não atingiu significância estatística na média

E com dev experiente, muda alguma coisa?

O ensaio da METR foi por outro caminho: 16 desenvolvedores open source experientes, 246 tarefas reais dos próprios repositórios, bases grandes de verdade (média acima de 1 milhão de linhas)

Com as ferramentas de IA, esses devs ficaram 19% mais lentos na média

Depois do experimento, estimaram ter ficado 20% mais rápidos

Se liga nisso: a percepção apontou pro lado OPOSTO da medição

De onde vem esse buraco entre sentir e medir

A pesquisa anual do Stack Overflow dá uma pista boa. A maior frustração dos desenvolvedores com IA é a solução ‘quase certa, mas não’: 66% citam isso

E 45% dizem que depurar código gerado por IA consome mais tempo

A confiança também não ajuda: na mesma pesquisa, 29% confiam na exatidão das saídas, 46% desconfiam e só 3% relatam confiança alta, enquanto 84% usam ou pretendem usar ferramentas de IA

O motivo de a percepção enganar é meio óbvio quando você para pra pensar: o tempo de digitar o código encolhe e isso é super visível, já o tempo de ler, conferir e caçar o erro quase certo se espalha em pedacinhos que ninguém contabiliza

O que você ganha e o que você perde ao delegar o código

Não é tudo perda, e fingir que é seria desonesto

Sobre a última linha, vale abrir os números

A pesquisa da GitClear sobre qualidade e manutenibilidade de código analisou 623 milhões de mudanças de código entre 2023 e 2026

Duplicação de blocos passou de 40,3 em 2023 para 73,0 no acumulado de 2026, uma alta de 81% sobre 2023

Copiar e colar dentro do próprio commit subiu de 9,4% em 2022 para 15,7% no primeiro semestre de 2026

E o sinal de refatoração foi na direção contrária: código movido caiu para 3,8% no acumulado de 2026, com chamadas de função entre arquivos 35% abaixo

Traduzindo pro dia a dia: mais código entrando, menos código sendo reorganizado 😅

Sinais de que você está desaprendendo (e como reverter)

Você não consegue explicar o trecho que acabou de commitar

O sintoma clássico. Alguém pergunta no review por que aquilo funciona e você só sabe dizer que passou no teste

Causa provável: engajamento cognitivo zero durante a geração. Você pediu, leu na diagonal e aprovou

Correção: antes de aceitar, escreva em uma frase o que aquele trecho faz e por quê. Se não sair a frase, você ainda não entendeu o código que está assinando

Travou quando o bug não é reproduzível pelo agente

Enquanto o erro aparece no terminal, tudo lindo. Quando o bug é de ambiente, de dado real ou de timing, a coisa para

Causa provável: a etapa de depuração foi a primeira a ser delegada, e é justamente a que mais caiu no estudo da Anthropic

Correção: assuma a investigação você mesmo. Levanta hipótese, isola, testa. O agente entra como consulta, não como detetive

O PR cresce e o repositório fica mais duplicado

Cada tarefa vira um bloco novo, parecidíssimo com outro que já existe três pastas ao lado

Causa provável: ausência da etapa de refatoração, que é exatamente o que a GitClear vê caindo enquanto a duplicação sobe

Correção: antes de pedir código novo, peça um mapa do que já existe pra aquela responsabilidade. Reaproveitar é decisão sua, não dele

Você aceita o diff sem ler

Esse é o mais silencioso, porque nada quebra hoje

Causa provável: confiança emprestada. Lembrando que 66% dos devs relatam a solução ‘quase certa, mas não’, então o diff bonito não é garantia de nada

Correção: leitura obrigatória, linha por linha, do que entra no commit

Como prevenir, resumido em duas regras que dá pra manter:

• ler o diff inteiro antes de aceitar, sempre, mesmo quando está óbvio
• reservar a depuração pra você, e chamar o agente só depois de ter uma hipótese

Veredito: o agente não rouba a habilidade, o modo de uso rouba

Vou ser direto e sem ficar em cima do muro

Primeiro o limite das evidências, porque ignorar isso seria vender fumaça: o estudo da Anthropic é com engenheiros majoritariamente juniores aprendendo uma biblioteca nova, o da METR é com sêniores em repositórios acima de 1 milhão de linhas, e nenhum dos dois testa exatamente o seu contexto

Agora o que dá pra sustentar com o que foi medido

O custo aparece na compreensão e principalmente na depuração

O ganho de tempo não é garantido, e a sua percepção de velocidade é péssima como medida

E tem o achado mais útil de todos: o estudo identificou 6 padrões de interação com a IA, e 3 deles envolvem engajamento cognitivo (pedir explicação, fazer perguntas conceituais, questionar o resultado) e preservam o aprendizado

Ou seja: não é o agente na mesa que apaga a habilidade, é o modo passivo de usar ele

Quando delegar ao Claude Code e quando escrever à mão

Tecnologia nova pra você: escreva o núcleo à mão

Esse é o cenário exato do estudo da Anthropic, biblioteca desconhecida, e foi onde a queda apareceu

Então escreve na mão a parte conceitual, aquela que você teria que explicar numa entrevista

O boilerplate ao redor, esse dá pra delegar sem dó

Quando a tecnologia nova é o próprio agente, a conversa muda de figura: aí faz sentido comparar aprender direto na ferramenta com um caminho de estudo mais guiado

Código de produção em base grande que você mantém: leia tudo

Foi nesse terreno que a METR mediu 19% mais lento com IA

Use o agente pra varrer, localizar e resumir, que é onde ele brilha, e mantenha a decisão e a leitura do diff com você

Bug de causa desconhecida: depure você

Depuração foi o item de maior queda no estudo, e 45% dos devs já dizem que depurar código gerado por IA consome mais tempo

Use o agente como consulta pontual (‘o que essa exceção costuma significar’), não como quem conduz a investigação

Tarefa repetitiva que você já domina: delega sem culpa

Aqui não tem habilidade nova em jogo. Migração mecânica, script de rotina, ajuste repetido em vários arquivos

O risco de duplicação continua, então a única regra que fica de pé é a leitura do diff

A régua pra decidir na hora

Juntando os quatro cenários, dá pra fechar numa pergunta só: essa tarefa é habilidade que você ainda está construindo, ou habilidade que você já tem?

Se já tem, delega, revisa o diff e segue a vida

Se ainda está construindo, escreve o miolo à mão e usa o agente pra explicar, questionar e revisar o que você escreveu

Delegar não é o problema, delegar justo a etapa que ainda ia te ensinar alguma coisa é 🙂

Como usar o Claude Code sem virar dependente dele

Agora a parte prática, só com o que está documentado na ferramenta

Se você ainda está montando a base e quer um caminho de estudo, tem um post separado sobre por onde começar no Claude Code

1. Abra em plan mode antes de deixar ele editar qualquer coisa. Segundo a documentação dos modos de permissão, no plan mode o Claude lê arquivos e explora, escreve um plano e não altera o código-fonte até a sua aprovação. Dá pra alternar os modos de permissão com Shift+Tab no terminal, ou já iniciar a sessão assim:

   claude --permission-mode plan

O erro comum deste passo: aprovar o plano no automático. Se você não leu o plano, o plan mode virou só um clique a mais

2. Ligue o output style Explanatory pra ver o porquê das escolhas. Pela documentação de output styles, ele entrega ‘Insights’ educacionais sobre escolhas de implementação e padrões do codebase, ou seja, o raciocínio junto com o resultado. A seleção sai por /config, no campo ‘Output style’, ou pelo campo outputStyle no arquivo de settings, e fica salva no nível do projeto em .claude/settings.local.json:

   {
     "outputStyle": "Explanatory"
   }

O erro comum deste passo: pular os Insights e ir direto pro código. É exatamente a parte que sustenta a compreensão conceitual

3. Use o Learning quando o objetivo for aprender, não entregar. A mesma documentação descreve o Learning como um modo de aprender fazendo: o Claude pede que VOCÊ escreva trechos estratégicos e marca esses pontos com TODO(human) no código. Aqui o engajamento cognitivo deixa de ser força de vontade e vira parte do fluxo. O erro comum deste passo: pular o TODO(human) e mandar o agente completar. Fazendo isso, você desligou justamente o que o estudo mostra que preserva o aprendizado

Um aviso pra fechar o bloco, porque ninguém gosta de surpresa na conta: Explanatory e Learning produzem respostas mais longas que o Default por design, o que aumenta o consumo de tokens de saída

É o preço de pedir explicação, e faz sentido usar esses estilos onde o aprendizado importa, não em toda tarefa mecânica

Conclusão

Voltando à pergunta do título: você aprende ou desaprende programando com o Claude Code? Depende inteiramente de você estar engajado ou só apertando enter

O que a medição mostra é que o modo passivo cobra caro na compreensão e na depuração, e nem sempre devolve a velocidade que parecia estar devolvendo

O próximo passo é pequeno e cabe nesta semana: escolhe UMA tarefa, roda em plan mode, ativa o estilo Learning e escreve você mesmo o trecho marcado como TODO(human)

Depois compara a sensação com a da última tarefa que você só aprovou

Não prometo que você vai virar outro dev em uma semana, isso ninguém mediu, mas dá pra saber muito rápido se você ainda consegue explicar o código que está assinando 🙂

Até o próximo post!