Bateu o limite de uso do Claude Code? Como retomar a tarefa sem refazer tudo

Você tá no meio de uma refatoração grande, o plano tá redondo na sua cabeça, e o Claude Code simplesmente para

Fala aí, beleza? Essa sensação de "perdi tudo" é quase sempre falsa: o limite não apaga arquivo nenhum, o código que já foi escrito continua no disco e o commit que você fez continua lá

O que dói de verdade é o contexto: a conversa inteira em que você explicou a arquitetura, decidiu o padrão de nomes, apontou os três bugs que ainda faltam

A proposta deste post é simples: sair da sessão com o estado registrado em algum lugar que não seja o chat, e voltar sem refazer o raciocínio do zero

Por que o corte aconteceu: janela de 5 horas e limite semanal

O sintoma é sempre o mesmo: a tarefa tá andando, a sessão trava e você fica olhando pro terminal sem entender o que aconteceu

A causa é que os planos pagos medem o uso do Claude Code de duas formas simultâneas: uma janela de sessão que reinicia a cada cinco horas e um limite semanal separado, contados ao mesmo tempo

Ou seja, dá pra estar tranquilo na janela de cinco horas e mesmo assim bater no teto da semana

A solução é descobrir qual dos dois estourou antes de sair chutando. Rode /usage dentro do Claude Code: ele abre o diálogo Account & usage, que mostra a conta logada, o plano e as barras de uso da sessão atual e da semana, com quanto falta pra cada limite reiniciar

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 108 aulas
• 4 projetos
• 9h

Conhecer formação

Quem está em plano Pro, Max, Team ou Enterprise por assento também consegue ver o mesmo consumo em Settings > Usage, com as barras de progresso da janela de cinco horas e do limite semanal

Pra prevenir: olhe as barras ANTES de abrir uma tarefa longa, não no meio dela. Se a semana já tá no fim da barra, o corte vai vir, é só questão de quando

E se a janela já fechou e você tá esperando, dá pra aproveitar o tempo: escrevi um post inteiro sobre o que fazer enquanto a janela não libera

Voltei e o Claude não lembra de nada: como retomar a sessão certa

O sintoma clássico: você reabre o terminal, digita claude, e o modelo te responde como se fosse o primeiro dia de trabalho dele no projeto

A causa quase nunca é perda de dado: é que você abriu uma sessão NOVA em vez de retomar a antiga

Se liga nas três formas de voltar:

Na prática, o -c resolve a maior parte dos casos: você volta pra pasta do projeto e continua de onde parou

cd ~/projetos/meu-app
claude --continue

O --resume é o que salva quando você mexeu em três projetos no mesmo dia e não lembra qual conversa era a boa

Pra prevenir: antes de começar uma tarefa longa, anote o ID da sessão num canto. É a diferença entre escolher a sessão certa na lista e ficar abrindo uma por uma pra ver qual é 🙂

E se a parada não foi por limite e sim por outro motivo, o caminho de volta é parecido: já falei sobre isso no post de quando o Claude Code trava

O que registrar antes de parar: checklist de 5 minutos

Aqui tá o pulo do gato: o estado da tarefa não pode morar na conversa, ele tem que morar no projeto

A conversa é volátil, o arquivo não é. Se você conhece a ideia de deixar um README pro seu eu do futuro, é exatamente isso, só que pro modelo ler também

1. Rode /usage e anote quanto falta pro reset

Saber que faltam quarenta minutos ou dois dias muda TOTALMENTE o que você escreve no passo seguinte

O erro comum: parar sem olhar e voltar no dia seguinte achando que a janela já virou

2. Escreva o estado da tarefa no CLAUDE.md da raiz do projeto

Esse arquivo markdown fica na raiz e o Claude Code lê ele no início de toda sessão. É o lugar natural pra padrões de código, decisões de arquitetura e instruções que precisam persistir

Algo assim já resolve:

   ## Estado atual da tarefa (atualizado antes de parar)

   Feito:
   - extraí o service de pagamento pra src/services/payment.ts
   - troquei as 4 chamadas diretas do controller pelo service

   Falta:
   - migrar os testes de integração que ainda apontam pro controller antigo
   - remover o arquivo legado src/legacy/pay.ts (só depois dos testes verdes)

   Decisão pendente:
   - manter retry no service ou subir pro middleware? ainda não decidi

Detalhe importante: o CLAUDE.md da raiz sobrevive à compactação. Depois do /compact, o Claude relê o arquivo do disco e reinjeta o conteúdo na sessão

O erro comum: escrever "continuar a refatoração" e achar que isso é estado. Não é. Estado é o que foi feito, o que falta e o que ficou em aberto

3. Confira o /memory pra ver o que já ficou salvo sozinho

O comando abre a pasta de memória automática, tudo em markdown que você pode ler, editar ou apagar. São quatro tipos de nota guardados entre sessões: user, feedback, project e reference

Vale a olhada porque às vezes metade do que você ia escrever na mão já tá lá

O erro comum: tratar a memória automática como backup do seu raciocínio. Ela é complemento, não substituta do arquivo que VOCÊ escreveu

4. Deixe o próximo passo pronto como primeiro prompt da volta

Escreva a frase exata que você vai colar quando a janela abrir. Sério, escreva ela

O erro comum: confiar na memória da conversa em vez do disco. A conversa some, o arquivo fica

Perdi edições no meio do caminho: rewind e os limites do checkpoint

Tem um cenário pior que perder contexto: a tarefa parar num estado quebrado, com metade da migração feita e nada rodando

Pra isso existe o /rewind. Você também chega nele apertando Esc duas vezes com o campo de prompt vazio

O menu lista cada prompt que você enviou na sessão e oferece três ações: Restore code and conversation, Restore conversation e Restore code

É ótimo, mas tem um limite que precisa ficar MUITO claro: o checkpointing só rastreia arquivos editados dentro da sessão atual

Ou seja, mudança que você fez na mão fora do Claude Code, ou que outra sessão rodando em paralelo fez, normalmente não é capturada. Tome cuidado com isso, porque é o tipo de coisa que você só descobre na hora errada

Pra prevenir: commite antes de tarefa grande e evite misturar edição manual na mesma janela em que o Claude tá trabalhando. O git é o cinto de segurança, o rewind é o airbag

O que aprendemos gravando sobre queima de token no Claude Code

No vídeo eu mostro dez coisas que fazem a cota evaporar sem você perceber, e a origem dele foi bem prática: minhas sessões passaram a durar menos e o consumo veio bem mais agressivo do que antes

Minha leitura é que o limite menor veio pra ficar, e que a saída é mudar o jeito de usar a ferramenta em vez de ficar reclamando do reset

Algumas coisas que eu mudei e que impactam direto o quanto você aguenta numa janela:

• CLAUDE.md enxuto, com as regras de negócio e as partes críticas do projeto, pro modelo não sair procurando informação em outro lugar. Eu peço pro próprio Claude gerar o arquivo e depois complemento na mão, mas atenção: arquivo grande demais volta a queimar token no input
• MCP só quando a tarefa pede. MCP instalado de forma global é levado pra todos os projetos e pode ser acionado à toa. Eu prefiro começar sem nenhum e conectar por projeto
• Nível de raciocínio proporcional à tarefa, em vez de deixar tudo no máximo pra sempre: o mais baixo em tarefa pequena, o médio como padrão depois que o projeto já existe, o alto no começo de projeto e em módulo novo, e o máximo só na fase de planejamento. Faça o teste antes de assumir que o nível baixo vai estragar o resultado!
• Comando de terminal rodado direto pelo Claude Code, em vez de pedir pro modelo executar. O exemplo que uso é subir o projeto com o script de dev do package.json, algo que o modelo só ia digitar por você mesmo
• Log de erro curto. No vídeo eu mostro um erro de umas 250 linhas em que a maior parte era irrelevante. Copio a primeira linha, ou abro o console e pego o trecho útil, algo entre cinco e dez linhas
• Modelo mais leve em tarefa simples, e de novo: isso precisa ser testado na prática, não aceito só no conceito

Do lado das ferramentas nativas, três coisas ajudam a fazer a janela render:

O Claude Code mostra um indicador ao vivo de quanto da janela de contexto já foi ocupado. Olhe pra ele, porque a qualidade cai quando a janela enche: as partes mais antigas deixam de ser vistas com clareza

Quando o indicador aperta, /compact resume as mensagens antigas preservando o contexto importante. Se a próxima tarefa não tem nada a ver com a anterior, aí é /clear, que zera o contexto pros próximos prompts

E o Shift+Tab troca o modo de permissão e ativa o plan mode, indicado na barra de status. Fechar o escopo em plan mode antes de deixar o modelo editar é uma das formas mais baratas de não gastar janela com trabalho que vai ser jogado fora

Pra quem usa API key a conta é outra: não tem teto de uso por plano, e o /cost mostra o gasto acumulado da sessão atual

No vídeo acima eu passo pelas dez dicas na prática, com os exemplos reais de contexto inchado, MCP ligado à toa e log gigante colado no chat

Como priorizar o que sobrou para a próxima janela

A janela reiniciou, beleza. Agora é não desperdiçar ela

1. Reabra a sessão certa, não uma nova

   claude --continue

Se você mexeu em vários projetos, use claude --resume e escolha da lista

O erro comum: rodar claude puro por costume e começar do zero sem perceber

2. Comece em plan mode com Shift+Tab

Assim o Claude relê o CLAUDE.md da raiz e te propõe o plano antes de sair editando arquivo

O erro comum: mandar "continua o que a gente tava fazendo" e descobrir dez minutos depois que ele entendeu outra coisa

3. Ataque primeiro o item que destrava os outros

Se os testes de integração bloqueiam a remoção do arquivo legado, é neles que a janela nova começa

O erro comum: escolher a tarefa mais fácil pra sentir progresso, e terminar a janela sem destravar nada

4. Use /compact quando o indicador de contexto encher

Você pode compactar com tranquilidade sabendo que o CLAUDE.md da raiz é relido do disco e reinjetado depois

O erro comum: deixar a janela lotar até a qualidade cair, e aí culpar o modelo

5. Feche a janela atualizando o estado no arquivo

Mesmo que ainda sobre cota. Cinco minutos de escrita valem uma hora de reexplicação depois

O erro comum: gastar a janela nova contando de novo o que é o projeto, o que é a stack e por que a decisão foi aquela

Limites mudam em 14 de setembro de 2026: o que isso significa

Em 29 de agosto de 2026 a Anthropic anunciou que, a partir de 14 de setembro de 2026, os limites semanais padrão do Claude Code sobem 25% de forma permanente para Pro, Max, Team e Enterprise por assento

Parece boa notícia, mas tem a outra metade: ao mesmo tempo se encerra o reforço temporário de 50% que estava em vigor desde maio de 2026

Juntando as duas pontas, o limite semanal a partir de 14 de setembro fica 17% menor do que o disponível hoje. Em base 100: hoje 150, depois 125

A consequência direta é bem chata de ouvir, mas é honesta: pra quem trabalha em tarefa longa, esse ritual de registrar estado antes de parar deixa de ser "boa prática" e vira rotina obrigatória

Menos janela semanal significa mais cortes no meio do caminho, e cada corte custa exatamente o tanto de contexto que você não escreveu em lugar nenhum

Conclusão

O limite de uso do Claude Code vira um incômodo pequeno quando o estado da tarefa mora no projeto, e não na conversa

O corte não apaga código: ele só apaga o raciocínio que você não registrou

Então o próximo passo é bem concreto: rode /usage agora pra saber onde você tá nas duas barras, crie ou revise o CLAUDE.md da raiz com um bloco de estado da tarefa, e teste a volta com claude --continue ANTES de precisar de verdade

Testar o resgate no dia calmo é bem melhor que descobrir como funciona no dia em que a janela fechou no meio da migração, né? 😀

até o próximo post!