Claude Code entrou em loop: vale insistir ou é melhor começar do zero?

Fala aí, beleza? Você corrige o Claude, ele concorda, pede desculpa, diz que entendeu direitinho

e refaz exatamente o mesmo erro

Aí você corrige de novo, dessa vez explicando melhor

E na terceira rodada ele ressuscita uma versão antiga do arquivo, aquela que você já tinha mandado jogar fora duas mensagens atrás 😅

Se liga nisso: não é teimosia do modelo e nem falta de capacidade. É contexto poluído. A sessão foi acumulando tentativa fracassada em cima de tentativa fracassada, e agora o histórico inteiro está empurrando o agente pro caminho errado

E tem uma boa notícia: a própria documentação do Claude Code dá uma régua objetiva pra você decidir entre insistir mais uma vez ou recomeçar do zero

(e só pra deixar claro, o loop do título é o loop ruim, não é o loop bom de deixar o agente rodando tarefas sozinho, que é outra história completamente diferente)

Bora ver na prática?

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

Como reconhecer que a conversa entrou em loop

Os sintomas clássicos:

Antes de sair digitando comando, vale reconhecer o padrão. Três sinais aparecem quase sempre juntos:

• o assistente repete o MESMO erro depois de você ter corrigido
• ele ignora uma instrução que você deu de forma explícita
• ele volta pra uma versão antiga do código, como se a última alteração nunca tivesse acontecido

Quando os três aparecem na mesma sessão, para de escrever prompt. O problema não está no seu texto, está no que já foi acumulado antes dele

Por que isso acontece:

Cada tentativa que deu errado continua ali no histórico, ocupando espaço e competindo com a sua correção mais recente

A doc ainda nomeia um segundo culpado: a kitchen sink session, a sessão balaio de gato. É aquela em que você começa uma tarefa, pergunta uma coisa sem relação nenhuma no meio, volta pra primeira, e no fim o contexto está cheio de informação irrelevante pro que você está fazendo AGORA

Já me ferrei com isso: você acha que está economizando tempo por não abrir uma sessão nova, e na real está construindo o problema

Como medir antes de decidir:

Duas coisas ajudam a sair do achismo

A primeira é contar. Quantas vezes você já corrigiu o mesmo ponto nessa sessão? Esse número é a sua régua, e daqui a pouco eu volto nele

A segunda é rodar o comando de diagnóstico:

/context

Ele mostra o uso atual do contexto numa grade colorida, com a quebra por categoria, sugestões de otimização pra ferramentas pesadas de contexto, aviso de inchaço de memória e aviso de capacidade. Inclusive quais arquivos CLAUDE.md e de memória automática foram carregados

É o jeito de responder "o que está entupindo essa conversa?" olhando dado, não palpite

E a prevenção é chata de tão simples: /clear entre tarefas que não têm relação uma com a outra, com frequência. A orientação é oficial e está nas boas práticas do Claude Code

A regra oficial das 2 correções:

Aqui está a régua que eu prometi

Se você corrigiu o Claude mais de duas vezes sobre o mesmo problema na mesma sessão, o contexto já está poluído por tentativas que falharam. A recomendação da doc é rodar /clear e recomeçar com um prompt mais específico, que incorpore o que você aprendeu nas tentativas anteriores

A doc é bem direta no porquê: uma sessão limpa com um prompt melhor quase sempre supera uma sessão longa cheia de correções acumuladas

Ou seja: recomeçar não é desistir. É trocar histórico ruim por instrução boa

Uma observação de escopo antes de seguir: tudo daqui pra baixo é comando do Claude Code no terminal. Se você fala com o agente por fora, através de um harness que conversa com vários agentes, o caminho até essas funções pode ser outro

/clear: recomeçar do zero sem perder o que importa

O medo que trava todo mundo:

O leitor lê "roda /clear" e congela

Porque a conversa até pode ser lixo, mas ali dentro tem as regras do projeto, o padrão de código, aquele detalhe do banco que você explicou com carinho

Jogar tudo fora parece caro demais

O que o /clear faz de fato:

/clear

Ele reseta a conversa para um contexto vazio. Os prompts seguintes rodam sem nenhum histórico anterior, começando do zero mesmo

O que SOBREVIVE ao /clear:

E aqui vem o alívio: o CLAUDE.md da raiz do projeto e a memória automática sobrevivem, porque são recarregados do disco

Ou seja, a memória de projeto não mora na conversa. Ela mora no arquivo

Se você conhece um .gitignore ou um .editorconfig, a lógica é parecida: está no repositório, é lido de novo, não depende de você ter falado dele na última mensagem

O que se perde (e você precisa trazer de volta):

As instruções que você deu APENAS dentro da conversa

Aquele "não mexe na pasta de migrations" que você digitou no chat e nunca escreveu em lugar nenhum? Some

Então o prompt novo precisa carregar essas regras de novo. Tome cuidado com isso, é o erro mais comum de quem recomeça: dar /clear e reescrever o pedido igualzinho ao primeiro, sem incorporar nada do que aprendeu

E se eu me arrepender?

Respira, o /clear não apaga a conversa antiga do disco

Ela continua salva e pode ser retomada passando o ID da sessão para a opção de resume. Tem uma seção inteira sobre isso mais pra baixo

/compact: quando a conversa vale, mas está pesada

Nem toda conversa merece a lixeira:

Tem caso em que o histórico é bom. Vocês investigaram um bug juntos, mapearam três arquivos, chegaram numa hipótese decente

O problema não é a qualidade, é o tamanho

Nesse cenário o /clear seria um desperdício

A alternativa:

/compact

Ele resume as mensagens antigas preservando o contexto importante, em vez de jogar tudo fora

Um requisito prático pra não te pegar de surpresa: a compactação exige uma conversa existente com pelo menos duas trocas anteriores pra ter o que resumir

O pulo do gato: compactar com instrução

Essa é a parte que pouca gente usa

O /compact aceita uma instrução junto do comando:

/compact focus on the auth bug fix

Assim o resumo guarda o que VOCÊ escolheu, em vez do que a passada automática acharia importante

É a diferença entre dizer "resume aí" e dizer "resume, mas o que importa é o bug de autenticação"

E a compactação automática?

O Claude Code compacta sozinho quando se aproxima do limite do contexto, e a ordem do processo é essa:

1. primeiro ele limpa saídas antigas de ferramentas
2. depois, se ainda for necessário, resume a conversa

O que fica preservado: os pedidos do usuário e trechos-chave de código

O que pode se perder: instruções detalhadas dadas lá no começo da conversa

Sacou o risco? Se a regra mais importante do seu trabalho foi dita na primeira mensagem de uma sessão gigante, ela é justamente a candidata a evaporar. Mais um motivo pra regra importante viver no CLAUDE.md, e não só no chat

/rewind: quando o código já foi estragado pela insistência

O estrago passou da conversa:

Às vezes não é só o papo que azedou

Depois de quatro tentativas, os arquivos ficaram inconsistentes: metade do refactor aplicado, um import órfão, uma função que voltou pra versão antiga

Aqui /clear não resolve nada, porque limpar a conversa não desfaz o que já foi escrito no disco

O mecanismo por trás:

Todo prompt que você envia gera um checkpoint

E os arquivos recebem um snapshot automático antes de cada mudança, justamente pra conseguirem ser restaurados depois

Ou seja, a rede de segurança já estava sendo montada enquanto você tentava

Com uma ressalva que vale guardar desde já: essa cobertura vale pras mudanças feitas pelas ferramentas de edição de arquivo do Claude, e não pra tudo que acontece no projeto. Já já eu detalho o que fica de fora

Como usar, passo a passo:

1. abra o menu de rewind, por um dos dois caminhos:

/rewind

ou apertando Esc duas vezes com o campo de prompt VAZIO

O erro comum deste passo: apertar Esc Esc com texto digitado no input. Limpa o campo antes

2. escolha o que volta atrás. As opções são: restaurar a conversa, restaurar o código, restaurar ambos, ou resumir a partir da mensagem selecionada

O erro comum deste passo: mandar restaurar tudo por reflexo. Nem sempre você quer perder a conversa, às vezes só o código precisa voltar

3. siga a partir dali com um prompt novo e mais específico, e não com a mesma frase que já falhou três vezes

O limite que evita frustração:

E aqui tem um detalhe que é MUITO importante entender antes de confiar cegamente no rewind

O checkpoint só rastreia mudanças feitas pelas ferramentas de edição de arquivo do Claude

O que NÃO é capturado:

• mudanças feitas via comandos Bash
• mudanças feitas por processos externos
• arquivos com symlink ou hard link, que não são revertidos

Então se o agente rodou um script que reescreveu meio projeto, o rewind não vai te salvar disso. Bom saber ANTES, e não no meio do desespero

Isso dura pra sempre?

Não

Os checkpoints são apagados junto com as sessões depois de um período de retenção, que por padrão é de 30 dias

E esse período é configurável pela configuração cleanupPeriodDays, caso você queira guardar por mais ou por menos tempo

Recomeçou e precisa voltar: como retomar a sessão anterior

O arrependimento clássico:

Você deu /clear, começou bonito, e três prompts depois lembrou daquele trecho de investigação que só existia na conversa antiga

Calma, dá pra voltar lá

Os três caminhos:

Por dentro de uma sessão em andamento:

/resume

Por fora, escolhendo numa lista:

claude --resume

Ou retomando direto a sessão mais recente do diretório atual:

claude --continue

Se não existir sessão nenhuma, o --continue imprime No conversation found to continue e sai. Caso essa mensagem apareça, não é bug, é só ausência de sessão naquele diretório

Detalhe do seletor que economiza tempo:

Por padrão, o seletor mostra as sessões da worktree atual

Se a conversa que você procura não está ali, dá pra ampliar a busca:

• Ctrl+W amplia para todas as worktrees do repositório
• Ctrl+A amplia para todos os projetos da máquina

E as sessões de background aparecem marcadas como bg, então dá pra identificar rapidinho o que é o quê

Qual comando usar em cada situação

Guia rápido pra quando você estiver no meio do problema e não quiser reler o post inteiro:

E fica o hábito que amarra tudo: ao recomeçar, leve só o essencial pro prompt novo

O que o Claude precisa saber é a conclusão que vocês chegaram, não o caminho torto que vocês percorreram até ela

Veja também: um recurso que ajuda a economizar contexto

Já que o assunto é gestão de contexto, tem material do canal que entra bem aqui

Pra começar do zero no tema, este vídeo apresenta o /btw, um recurso do Claude Code voltado a economizar tokens, e serve como introdução pra quem está entrando agora nessa conversa de contexto e consumo:

Conclusão

Recapitulando o que importa:

A régua oficial é a das 2 correções. Passou disso no mesmo ponto, para de insistir e recomeça com um prompt mais específico, porque sessão limpa com prompt melhor quase sempre bate sessão longa cheia de correção acumulada

Recomeçar não é perder trabalho. O CLAUDE.md do projeto e a memória automática sobrevivem ao /clear, e a conversa antiga continua salva em disco pra ser retomada pelo ID da sessão

Se o histórico ainda vale, /compact com instrução. Se o estrago foi nos arquivos, /rewind, lembrando do limite dele

O próximo passo prático é esse: da próxima vez que você se pegar corrigindo a mesma coisa pela segunda vez, roda /context, olha o que está pesando, decide entre /compact e /clear, e reescreve o prompt já com tudo que você aprendeu nas tentativas anteriores

É o tipo de hábito que parece bobo e que economiza uma tarde inteira 😀

até o próximo post!