Quando interromper o Claude Code no meio da tarefa (e o que fazer com o que ficou pela metade)

Tem poucas coisas mais frustrantes que ficar olhando o agente construir, com capricho, uma coisa que você JÁ decidiu que vai jogar fora

Acontece direto: você pede um ajuste pequeno, o Claude Code entende outro problema no primeiro passo e sai reescrevendo meio arquivo. Aí bate aquela paralisia de "deixa terminar pra ver no que dá"

Só que deixar terminar não é neutro, é caro: gasta token, gasta contexto e ainda te devolve um diff gigante pra revisar antes de descartar tudo

A parte boa é que existe caminho seguro pra cortar no meio: Esc, checkpoint automático e /rewind

Então o post tem duas metades: COMO perceber que vale cortar antes do fim, e o que fazer com o pedaço que ficou pela metade

Bora?

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

O que precisa estar no lugar antes de cortar sem medo

Antes de sair apertando Esc na cara dura, três coisas precisam estar claras na sua cabeça

1. O repositório sob Git, sempre

A documentação oficial posiciona o Claude Code como não substituto do Git: o checkpointing serve pra recuperação rápida dentro da sessão, o Git é o histórico durável, com commits e branches

Se você conhece o fluxo de commitar antes de mexer em algo grande, é exatamente isso. O checkpoint é a rede de segurança de curto prazo, o commit é o chão

2. O checkpoint acontece sozinho

Não tem configuração manual: o estado do código é capturado antes de cada prompt do usuário

Ou seja, cada vez que você manda uma mensagem, existe uma foto do antes. É isso que torna o corte no meio barato

3. O limite que mais dói: bash fica de fora

O checkpointing rastreia apenas edições feitas pelas ferramentas de edição de arquivo do Claude. Alteração que passou por comando bash (rm, mv, cp e os rm -rf da vida) NÃO é revertida pelo rewind

Tome cuidado com isso, porque é o ponto onde a rede tem buraco. É também o motivo do item 1 existir 😀

Sinais de que a execução saiu do rumo (e vale cortar antes do fim)

A régua aqui é simples: se você já não quer o resultado, cada segundo a mais é desperdício. Se você tem que revisar um trabalho que vai descartar, o custo dobra, e quanto o Claude Code custa hoje faz esse desperdício doer bem mais rápido do que parece

Se liga nos padrões observáveis na tela

O agente editou um arquivo fora do que você pediu

Causa provável: pedido amplo demais. Você falou "arruma o login" e ele interpretou que o roteamento inteiro fazia parte do login

O que fazer: Esc agora. Quanto mais arquivo entra no diff, mais caro fica separar o que presta do que não presta

Ele começou a reescrever em vez de ajustar

Causa provável: faltou contexto do porquê aquele código está daquele jeito. Sem isso, reescrever parece mais limpo que remendar

O que fazer: Esc e devolver o contexto que faltava no próximo pedido, deixando explícito o que NÃO pode ser tocado

Ele está apagando ou movendo arquivo por bash

Causa provável: o agente decidiu "limpar" alguma coisa no lugar de você

O que fazer: Esc na hora. Essa é a zona fora do rewind: o que sair por bash não volta pelo menu de checkpoints, só pelo Git

Ele repete a mesma tentativa que já falhou

Causa provável: o erro real está fora do que ele consegue ver, então ele fica girando na mesma hipótese

O que fazer: Esc e mudar o pedido, não o volume. Insistir mais não muda a hipótese, muda só a conta

Você percebe, no primeiro passo, que ele entendeu outro problema

Esse é o mais barato de todos pra cortar, e o que a gente mais deixa passar

O que fazer: Esc imediatamente. É literalmente o melhor momento possível pra interromper o Claude Code, porque quase nada foi tocado ainda

Como prevenir isso antes de começar

O modo de planejamento existe pra isso: Shift+Tab cicla os modos de permissão no CLI, e dá pra prefixar um prompt com /plan pra aplicar o modo àquele pedido

Nele o Claude lê arquivos e propõe um plano, sem editar o código até você aprovar

É como pedir pro cara olhar a casa e te falar o que pretende quebrar, antes de entrar com a marreta

Passo a passo: interromper e tratar o que ficou pela metade

1. Aperte Esc uma vez, sem digitar nada antes

Um Esc interrompe a resposta ou a chamada de ferramenta em curso, mantém o contexto e a conversa até ali, e devolve o controle pra você. O que já tinha sido feito é preservado e a sessão continua viva

O erro comum deste passo: digitar a correção primeiro. Com texto no input, o Esc duplo limpa o rascunho em vez de abrir o menu de checkpoints (e o rascunho volta pela seta pra cima, então respira 🙂)

2. Confira o estado real com Git

git status
git diff

Aqui você vê o tamanho verdadeiro do estrago, incluindo o que passou por bash e que o rewind não vai desfazer

O erro comum deste passo: confiar na descrição do que o agente disse que fez, em vez de olhar o diff

3. Decida entre seguir do ponto atual ou reverter

Se o caminho estava certo e só passou do ponto, seguir dali costuma ser mais barato. Se a direção estava errada desde o começo, reverter é o movimento

O erro comum deste passo: tentar consertar por cima de uma base que você já não quer. Aí você paga duas vezes

4. Abra os checkpoints com Esc Esc ou /rewind, com o input vazio

O menu deixa escolher o que restaurar: código e conversa, só a conversa (mantendo o código atual) ou só o código (mantendo a conversa)

Essa terceira opção é ouro quando o código azedou mas a conversa até ali tem contexto bom que você não quer perder

O erro comum deste passo: achar que o rewind cobre tudo. O que saiu por bash não está lá

5. Reformule o pedido menor e mais explícito

Menos escopo, mais limite. Diga o arquivo, diga o que não pode ser tocado, e se a tarefa for grande, entre em plan mode antes de liberar edição

É aqui também que vale pensar em qual modelo usar em cada tarefa, porque tarefa reformulada e pequena às vezes nem pede o modelo mais caro

O erro comum deste passo: repetir o mesmo prompt achando que a segunda rodada sai diferente

6. Retome depois, se for o caso

As conversas ficam salvas localmente e dá pra voltar pela linha de comando

claude --continue
claude --resume

O --continue retoma a sessão mais recente e o --resume abre a lista pra você escolher. E os checkpoints são salvos junto com a conversa, então o /rewind continua disponível depois de retomar

O erro comum deste passo: abrir uma sessão nova do zero e perder o contexto que já estava construído

Quando NÃO interromper (e o que fazer no lugar)

Cortar nem sempre é o movimento certo, beleza? Tem caso em que o Esc só te faz perder trabalho bom

Comando longo que só precisa sair da frente: no modo interativo, Ctrl+B move o comando pra segundo plano. Não precisa matar o que está rodando só porque você quer a atenção do agente de volta

Correção pequena de rumo: se você digitar a correção e apertar Enter sem Esc, não tem interrupção. A ferramenta em execução termina e a mensagem entra na fila, sendo lida no próximo ponto de decisão. Ela ajusta o passo seguinte, não o passo atual

Isso é ótimo quando você quer só refinar, e péssimo quando você achava que tinha parado tudo

Frente de trabalho paralela: a documentação sugere tratar sessões como branches, cada frente com seu contexto próprio. Não interrompa a tarefa A pra pedir a tarefa B, abra sessão separada

E guarde o limite operacional: o Claude Code mantém snapshots dos 100 checkpoints mais recentes por sessão, e os checkpoints são apagados junto com as sessões após um período de retenção, 30 dias por padrão, alterável via cleanupPeriodDays

Traduzindo: rede de segurança de sessão, não arquivo histórico. O Git segue sendo o durável

Conclusão

A régua prática é essa: interromper cedo custa menos que revisar um resultado que você já sabe que vai descartar

O Esc uma vez para sem derrubar a sessão, o checkpoint automático guarda o antes de cada prompt, o /rewind deixa escolher o que volta, e o Git cobre justamente o buraco do bash

Próximo passo concreto, bem simples: commite antes da próxima tarefa grande e rode ela em plan mode

Assim, se o corte vier, ele sai barato…

até o próximo post! 😀