Contexto cheio no Claude Code: o que fazer quando a sessão longa começa a piorar as respostas

Fala aí, beleza? Existe um momento muito específico numa sessão longa de Claude Code que todo vibe coder já viveu: ele erra uma coisa que ele MESMO acertou meia hora atrás

Você explica de novo, ele pede o caminho de um arquivo que já leu, reintroduz um bug que vocês dois já mataram

A sensação é de que o modelo ficou burro do nada

Não ficou

O que aconteceu foi a janela de contexto enchendo, e isso tem nome, tem mecanismo explicado e tem um conjunto de movimentos pra recuperar o rumo. Bora entender e resolver?

Por que as respostas pioram em sessões longas (context rot)

O que você vê na tela:

Ele repete uma pergunta que você já respondeu

Esquece a decisão de arquitetura que vocês fecharam no começo da conversa

Reescreve um trecho de um jeito que já tinha sido descartado

E o pior: reintroduz um bug que já estava corrigido

Por que isso acontece:

O nome do fenômeno é context rot: conforme o número de tokens no contexto cresce, a capacidade do modelo de recuperar informação daquele contexto com precisão diminui

Quanto mais tokens acumulados, pior a recuperação

E tem o mecanismo por trás disso: LLMs trabalham com um orçamento de atenção finito, e cada novo token consome um pedaço dele. Em transformers a atenção é distribuída por softmax normalizado ao longo de TODO o contexto

Ou seja: contexto maior significa peso de atenção progressivamente diluído por token

Se você conhece aquela sensação de tentar prestar atenção em cinco conversas ao mesmo tempo numa mesa de bar, é mais ou menos isso, só que com matemática

A documentação de boas práticas do Claude Code é bem direta nesse ponto: a maior parte das recomendações parte de uma restrição só, que é a janela de contexto encher rápido e o desempenho degradar conforme ela enche

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 tratar isso:

A virada de chave é parar de tratar a janela como espaço infinito e começar a tratar como recurso escasso

Nada do que entra no contexto é de graça, nem o arquivo que ele leu "só pra dar uma olhada", nem o output gigante daquele comando de teste

E isso não é defeito exclusivo de uma ferramenta: se você tá naquela dúvida entre Claude Code ou Cursor, saiba que o orçamento de atenção é o mesmo em qualquer assistente que lê código de verdade

Pra prevenir: não deixe a sessão crescer sem checkpoint. Bloco fechado, resultado gravado, contexto limpo

Diagnóstico: use /context antes de decidir o que fazer

O sintoma:

Você sente que tá lento e impreciso, mas não sabe o motivo

Aí fica naquele chute: "será que compacto? será que zero tudo? será que troco de tarefa?"

A causa:

Não dá pra consertar o que você não mede

Um monte de coisa ocupa espaço sem aparecer na tela: os arquivos CLAUDE.md carregados, as notas de auto memory, os resultados de ferramenta que voltaram enormes

A solução:

O comando /context mostra um detalhamento AO VIVO do uso de contexto por categoria, com sugestões de otimização

/context

Ele inclui quais arquivos CLAUDE.md e de auto memory foram carregados, então você para de adivinhar e vê onde o espaço tá indo

Pra prevenir: rode antes de começar tarefa grande, não só quando o incêndio já começou 🙂

A sessão compacta o tempo todo: /compact, /clear e /autocompact

O sintoma:

Passes de compactação aparecendo de dez em dez minutos e aquela perda do fio da meada logo depois

A causa:

Sem tamanho de janela configurado, o Claude Code compacta quando a conversa atinge o limite de contexto do modelo

Ou seja: quem escolhe a hora do corte é a máquina, não você. E o corte quase sempre cai no pior momento possível

As três saídas:

O /compact resume as mensagens antigas pra liberar espaço, mantendo a MESMA sessão em andamento

O /clear reseta a conversa pra um contexto vazio, e os prompts seguintes começam sem nenhum histórico. Detalhe importante que muita gente não sabe: a conversa antiga continua em disco e pode ser retomada passando o session ID pra opção de resume

E o /autocompact aceita uma contagem de tokens pra definir quão cheia a janela fica antes do passe automático rodar:

/autocompact 500k

Repare que isso é diferente de MUDAR o tamanho da janela: também dá pra definir a janela de contexto com um número simples, de 100 a 1000, interpretado em milhares. Então 200 configura 200.000 tokens

Um mexe no limiar do corte automático, o outro mexe no tamanho do espaço disponível, beleza?

Se você quer se aprofundar em quando usar cada um, eu detalhei isso em gerenciar contexto no Claude Code

Pra prevenir: escolha o momento do corte em vez de sofrer o automático no meio de um raciocínio

Errou o rumo no meio da sessão: /rewind em vez de argumentar

O sintoma:

Ele tomou uma decisão ruim e você gastou seis mensagens tentando desfazer

"não, não é assim", "volta o que você fez", "eu tinha pedido o contrário"

E cada tentativa enche MAIS o contexto

A causa:

Discutir o erro custa tokens e, de quebra, mantém o erro inteirinho no histórico

O caminho errado continua lá, competindo por atenção com o caminho certo

A solução:

O comando /rewind volta a conversa e/ou o código pra um ponto anterior, ou resume a partir de uma mensagem selecionada

Você escolhe: restaurar só a conversa, só o código, os dois, ou gerar um resumo a partir da mensagem escolhida

É o "ctrl+z" que evita a discussão inteira

Pra prevenir:

Use plan mode quando você tá incerto sobre a abordagem, quando a mudança altera múltiplos arquivos ou quando você não conhece o código que vai ser modificado

Agora, pra escopo claro e correção pequena (corrigir um typo, adicionar um log, renomear uma variável) a orientação é pedir direto

Planejar um rename de variável é queimar contexto à toa, né? 😀

Perdeu as decisões ao recomeçar: memória em arquivo

O sintoma:

Você deu /clear, respirou aliviado, e a sessão nova refez discussões que já estavam fechadas

Pior: tentou de novo exatamente o caminho que já tinha falhado ontem

A causa:

O /clear apaga o contexto

E o que não está em arquivo não volta. Simples assim

A solução:

O Claude Code tem dois sistemas de memória complementares: os arquivos CLAUDE.md (instruções escritas por você) e a auto memory (notas que o próprio Claude escreve a partir das suas correções e preferências)

Os dois são carregados no início de TODA conversa

O CLAUDE.md do projeto pode ficar em ./CLAUDE.md ou em ./.claude/CLAUDE.md

E tem uma mecânica de carregamento que vale entender: arquivos CLAUDE.md e CLAUDE.local.md na hierarquia acima do diretório de trabalho são carregados por INTEIRO na inicialização, enquanto os de subdiretórios carregam sob demanda, quando o Claude lê arquivos daquelas pastas

Tome cuidado com isso: memória lá em cima da hierarquia é custo fixo em toda sessão

Na primeira sessão de um repositório, a recomendação é rodar /init pra gerar um CLAUDE.md inicial e depois /memory pra refinar

/init
/memory

O /memory permite editar os arquivos CLAUDE.md, ligar ou desligar a auto memory e ver as entradas dela. A auto memory vem ligada por padrão, e o toggle salva autoMemoryEnabled nas configurações de usuário em ~/.claude/settings.json

Um limite que muita gente descobre do jeito errado: as primeiras 200 linhas do MEMORY.md, ou os primeiros 25KB, o que vier primeiro, são carregadas no começo de toda conversa

O que passa disso não entra no início da sessão

Então memória gigante não é memória melhor, é memória cortada

O arquivo de progresso:

Esse aqui é o item que mais salva sessão longa

Um bom arquivo de progresso rastreia status atual, tarefas concluídas, abordagens que falharam e por que não funcionaram, tabelas de acurácia em checkpoints e limitações conhecidas

As abordagens que falharam são o pulo do gato: sem elas, as sessões seguintes tentam de novo os mesmos becos sem saída

Já me ferrei com isso mais de uma vez, batendo de novo na mesma porta fechada porque ninguém anotou que ela estava fechada

Como dividir uma tarefa grande em blocos que cabem numa sessão

A Anthropic formalizou três estratégias complementares pra agentes de longo horizonte: compactação (compaction), anotação estruturada (structured note-taking) e arquiteturas de subagentes

Na prática do dia a dia, isso vira uma rotina de fatiamento. Bora ver o passo a passo?

1. Escreva o objetivo do bloco em uma linha antes de abrir a sessão. Refatoração ampla vira "extrair a validação pra um middleware", migração vira "migrar só a camada de acesso a dados", investigação de bug longo vira "reproduzir e isolar a causa", leitura de acervo grande vira "mapear os pontos de entrada". O erro comum deste passo é abrir o terminal e pedir "refatora o projeto inteiro": aí a janela enche antes do primeiro resultado útil

2. Rode /context antes de começar o bloco. Você vê o que já tá ocupando espaço sem ter feito nada ainda. O erro comum aqui é ignorar o custo fixo da memória e do CLAUDE.md, e depois estranhar que a sessão "nasceu" pela metade

3. Delegue a exploração pesada pra um subagente. Cada subagente começa com uma janela de contexto NOVA e isolada: ele não vê seu histórico de conversa, nem as skills já invocadas, nem os arquivos que o Claude já leu. As chamadas de ferramenta intermediárias e os resultados ficam DENTRO dele, e só a mensagem final volta pra conversa principal. O erro comum é achar que o subagente enxerga o que vocês combinaram: o único conteúdo passado do pai pro subagente é a string de prompt da ferramenta Agent, então tudo que ele precisa saber tem que estar escrito ali

4. Rode subtarefas independentes em paralelo. Vários subagentes podem rodar simultaneamente, então subtarefas independentes terminam no tempo da mais lenta, em vez da soma de todas. Mto massa pra varredura de código

5. Feche o bloco gravando o resultado em arquivo. O Claude pode usar arquivos como rascunho temporário (temporary scratchpad) antes de salvar a saída final, e isso melhora resultados especialmente em casos de uso de coding agêntico. O erro comum é deixar a conclusão só no chat: aí o /clear leva junto

6. Dê /clear e comece o próximo bloco lendo o arquivo. A sessão nova nasce limpa, mas informada

Repare no encaixe: a compactação é o passo 6, a anotação estruturada é o passo 5, e os subagentes são os passos 3 e 4

As três estratégias não são alternativas, elas trabalham juntas

O que eu vi na prática: sessão esticada com filtro de contexto

Aqui entra experiência relatada, não medição de laboratório, beleza? Os números abaixo são os que EU observei numa sessão de teste com o plugin Context Mode, e eu mostro tudo no vídeo

O ponto de partida: sem nenhum filtro, na minha experiência a sessão andava uns 10 a 20 minutos antes de bater na compactação

Com o plugin, ela passou de uma hora

No teste eu rodei três prompts encadeados num projeto real que eu já tinha pronto: análise completa do código (estrutura, dependências, autenticação, comunicação frontend/backend e vulnerabilidades), correção das falhas de segurança mais críticas com extração da validação pra um middleware reutilizável, e criação de um recurso novo de estatísticas com endpoint e seção visual no dashboard

Esses três prompts eu planejei DEPOIS de pedir um arquivo CLAUDE.md ao Claude e ler o resultado, então eu sabia o que estava acontecendo no projeto antes de mandar bala

O status do plugin ao fim dos três prompts:

• 84 KB de dados processados na sessão
• 40 KB retidos fora do contexto
• 40 KB que efetivamente entraram no contexto
• 50% de redução de tráfego de tokens reportada

E no infográfico que eu montei pro vídeo tem o exemplo que ilustra a lógica: um contexto de 56 KB virando aproximadamente 299 bytes do lado do modelo

A ideia é essa: o processamento pesado acontece fora, e só o resumo volta pro contexto

O plugin também vai gravando o contexto da sessão localmente e reinjeta essas informações quando o Claude compacta, pra ele não esquecer onde estava

Sendo honesto: essa reinjeção aumenta um pouco o consumo

Mas eu acho a troca válida, porque o que volta é informação pertinente ao projeto, e não histórico de conversa fiado

Conclusão: transformar isso em rotina

Sessão longa não é sinal de produtividade

Sessão longa é sinal de contexto acumulado, e contexto acumulado é atenção diluída

O recado central é esse: o modelo não piorou, a janela encheu. E janela cheia tem tratamento conhecido, que é medir, cortar no momento certo e deixar por escrito o que não pode ser esquecido

Se você quer sair daqui com três ações concretas pra próxima sessão:

1. Rodar /context antes da primeira tarefa grande do dia
2. Criar o CLAUDE.md com /init e refinar com /memory
3. Adotar o arquivo de progresso (status, feitos, abordagens que falharam e por quê) ANTES do primeiro /clear

Uma nota de escopo pra fechar, porque isso confunde bastante gente: context editing (que limpa automaticamente chamadas e resultados de ferramenta obsoletos ao se aproximar dos limites de token) e memory tool (que guarda e consulta informação fora da janela num sistema baseado em arquivos) são recursos da Claude Developer Platform

Não são comandos do Claude Code, então não adianta procurar no terminal 😛

Vale também lembrar que o Claude Code já otimiza custo sozinho por prompt caching e por auto-compactação, mas otimização automática não substitui escopo fechado

Testa a rotina no seu próximo bloco de trabalho e vê a diferença… até o próximo post!