Gestão de contexto no código Claude

O Claude Code tem agora uma janela de contexto de 1M. Isso muda muita coisa. Mas não altera a regra fundamental: uma janela maior não resolve uma má gestão de sessões.

O que realmente determina os resultados é a decisão que tomas após cada jogada:

• continuar na mesma sessão
• /rewind para um ramo melhor
• /clear e começar do zero
• /compact e manter o resumo
• mover o próximo bloco para um subagente

Essa é a verdadeira camada de gestão de contexto no Claude Code. A maioria das sessões ruins não é causada por um modelo fraco. Elas são causadas por levar o contexto errado adiante por muito tempo.

A orientação oficial da Anthropic de 15 de abril de 2026 reforçou este ponto: cada turno é um ponto de ramificação. Esta página transforma isso num sistema operativo prático.

Resultado rápido

Usa estas duas regras imediatamente:

1. Nova tarefa, nova sessão. Se o trabalho mudou significativamente, executa /clear ou inicia uma nova sessão em claude.
2. Caminho errado, volta atrás em vez de corrigir. Se o Claude seguiu pela ramificação errada, usa o /rewind em vez de empilhar "isso não funcionou, tenta isto em vez disso" em cima de um contexto obsoleto.

Se adotares apenas esses dois hábitos, a qualidade média das tuas sessões vai melhorar rapidamente.

Contexto, compactação e deterioração do contexto

A janela de contexto é tudo o que o modelo pode ver para a sua próxima resposta:

• prompt do sistema
• o teu histórico de conversas
• chamadas e saídas de ferramentas
• ficheiros lidos no contexto
• memória carregada e instruções

O Claude Code consegue armazenar muito mais do que antes. Isso não significa que o contexto seja livre.

À medida que o contexto cresce, o desempenho pode deteriorar-se. A Anthropic chama a isto «deterioração do contexto»: a atenção dispersa-se por mais tokens, o material obsoleto permanece, e detalhes antigos e irrelevantes começam a competir com a tarefa que realmente te interessa agora.

Quando a janela fica demasiado cheia, o Claude Code compacta a sessão. Isso significa que a conversa atual é resumida numa descrição mais curta e o trabalho continua com base nesse resumo. Útil, mas com perdas.

O erro principal é tratar o contexto como um arquivo. Não é um arquivo. É memória de trabalho ativa.

Cada Turno é um Ponto de Ramificação

Assim que o Claude terminar uma jogada, tens várias opções válidas. A escolha certa depende de o contexto atual ainda ser relevante.

Se te lembrares de uma tabela desta página, usa essa.

Cinco cenários do dia a dia

É aqui que as abstrações se tornam úteis. A maioria das sessões reais encaixa-se num destes padrões.

1. A implementação de funcionalidades transforma-se em documentação

Acabaste de terminar o middleware de autenticação e agora queres notas de migração e documentação para essa mesma alteração.

Melhor opção: continua na mesma sessão

Porquê: o código, as decisões e os casos extremos ainda são úteis. Recriar esse estado só iria custar tempo.

2. O Claude escolheu o caminho de implementação errado

Ele leu os ficheiros certos, mas depois comprometeu-se com uma abordagem que não se encaixa na base de código.

Melhor opção: /rewind

Porquê: mantém a exploração útil, descarta o ramo que falhou.

3. Uma tarefa, demasiados resíduos de depuração

Ainda estás na mesma funcionalidade, mas a sessão está cheia de falsos começos e registos sem saída.

Melhor jogada: /compact com uma dica

Porquê: a tarefa continua a ser a mesma; a sessão só precisa de ser podada.

4. Estás a passar da programação para o planeamento do roteiro

Domínio relacionado, formato de tarefa diferente.

Melhor opção: /clear ou começa uma sessão nova

Porquê: os resíduos da implementação são agora, na sua maioria, ruído.

5. Precisas de uma auditoria abrangente, mas só a conclusão importa

Queres uma investigação paralela noutro repositório, uma verificação de especificações ou uma pesquisa abrangente.

Melhor opção: subagente

Porquê: mantém o ruído intermédio fora do thread principal.

Quando permanecer na mesma sessão

Continua na mesma sessão quando:

• ainda for a mesma tarefa
• os ficheiros que o Claude acabou de ler ainda forem diretamente relevantes
• a cadeia de raciocínio atual ainda for útil
• reler tudo seria mais lento e mais dispendioso do que continuar

Exemplo clássico: acabaste de implementar uma funcionalidade e agora queres que o Claude escreva a documentação para essa mesma funcionalidade. Começar do zero funcionaria, mas o Claude teria de reler o código que já tem no contexto. Se a tarefa for semelhante e a sessão atual ainda estiver suficientemente clara, faz sentido continuar.

A questão não é «isto está relacionado?» A questão é «este contexto atual ainda ajuda?»

Quando iniciar uma nova sessão

A regra geral da Anthropic é simples: quando começas uma nova tarefa, deves também iniciar uma nova sessão.

Começa do zero quando:

• tiveres mudado de uma funcionalidade para outra
• a sessão contiver muita depuração ou ruído de exploração
• a ramificação anterior do trabalho estiver concluída
• a próxima tarefa precisar de ficheiros diferentes, objetivos diferentes ou restrições diferentes

Isto é importante mesmo com 1M de contexto. A janela maior dá-te mais espaço antes da compactação. Não torna o contexto irrelevante inofensivo.

Bons exemplos de uma mudança para uma sessão nova:

• concluí a refatoração da autenticação, agora estou a começar a faturação
• concluí a implementação, agora estou a fazer o planeamento do roteiro
• passei 40 minutos a depurar uma falha, agora vou mudar para um problema diferente

Se precisares de continuidade, escreve uma breve passagem de testemunho no primeiro prompt da nova sessão:

We just finished the auth middleware refactor.
What matters for this new task:
- the session format stayed unchanged
- files that matter now are X and Y
- we ruled out approach Z

New task: write the migration notes and docs.

Isso costuma ser mais claro do que arrastar toda a sessão antiga para a nova.

Rewind em vez de corrigir

/rewind é uma das ferramentas de gestão de sessões mais poderosas do Claude Code e uma das menos bem utilizadas.

Quando o Claude lê um monte de ficheiros, escolhe a abordagem errada e tu respondes com:

That didn't work. Try B instead.

estás a manter a tentativa falhada, o seu raciocínio e a tua correção, tudo dentro do mesmo contexto. Às vezes, isso é aceitável. Muitas vezes, é apenas uma contaminação.

Padrão melhor:

1. recuar até ao ponto logo a seguir à exploração útil
2. mantém as leituras de ficheiros valiosas
3. descarte o ramo falhado
4. pede novamente a partir daí com o que aprendeste

Exemplo:

Don't use approach A. The foo module does not expose that.
Go straight to approach B using the existing adapter in src/lib/foo.ts.

Isso dá ao Claude o contexto útil sem a ramificação errada acumulada por cima.

O rebobinar é melhor quando:

• a exploração foi útil
• a tentativa de implementação estiver errada
• aprendeste algo específico
• queres manter as evidências, mas não o caminho do fracasso

/compact vs /clear

Estes não são intercambiáveis.

Usa «/compact» quando:

• ainda for a mesma tarefa
• a sessão está sobrecarregada
• queres que o Claude preserve os aprendizados importantes
• o trabalho continua na mesma direção

Podes controlar a compactação:

/compact focus on the auth refactor, drop the test debugging

Isso é especialmente útil agora que o contexto de 1M te dá mais tempo para compactar de forma proativa, antes que o modelo chegue ao seu pior estado de contexto.

Usa /clear quando:

• for uma tarefa nova
• já não confias no contexto atual
• queres controlo total sobre o que sobrevive
• preferires escrever tu mesmo a transferência em vez de confiar num resumo com perdas

A diferença é simples:

• /compact pede ao Claude para decidir o que era importante
• /clear deixa**-te** decidir o que é importante

O que causa um mau compacto

A explicação da Anthropic é útil aqui: compactos ruins geralmente acontecem quando o modelo não consegue prever a direção que o teu trabalho vai tomar a seguir.

Exemplo:

1. passas uma longa sessão a depurar um problema
2. o autocompact é acionado
3. o resumo concentra-se nesse caminho de depuração
4. o teu próximo prompt muda para um problema diferente, mas relacionado
5. o detalhe que querias foi omitido porque o autocompact achou que não era relevante

É por isso que o «/compact» manual supera o «autocompact» passivo em muitos trabalhos reais. Podes dizer ao Claude qual é a próxima direção antes de ele resumir.

Uma regra útil:

• se sabes qual é a próxima fase, faz a compactação antes que o Claude tenha de adivinhar

Mau:

• depurar durante 45 minutos
• deixa o autocompactar disparar
• depois mudar de direção de repente

Melhor:

• concluir a fase de depuração
• executa o /compact focus on the fix plan and the files that matter next
• continua para a implementação

Os anti-padrões a evitar

Uma má gestão de contextos geralmente não é dramática. É apenas uma série de pequenas decisões preguiçosas.

Fica atento a isto:

• Usar uma sessão maratona para trabalhos não relacionados
• Corrigir um ramo mal feito em vez de o rebobinar
• Esperar pela autocompactação quando já sabes qual é a próxima fase
• Deixar que pesquisas ruidosas aconteçam na sessão pai
• Considerar «relacionado» como motivo suficiente para continuar

Estes são os hábitos que fazem com que um modelo forte pareça inconsistente.

Usa subagentes para manter o ruído intermédio afastado

Os subagentes não são apenas uma ferramenta de delegação. São uma ferramenta de gestão de contexto.

O teste mental antropico é forte:

Vou precisar deste resultado intermédio novamente, ou apenas da conclusão?

Se a resposta for «apenas a conclusão», um subagente é muitas vezes a opção mais clara.

Bons candidatos a subagentes:

• ler outra base de código e resumir um padrão
• verificar uma implementação em relação a uma especificação
• escrever documentação a partir do teu git diff
• fazer uma pesquisa abrangente que não queiras sobrecarregar o thread principal
• executam uma auditoria focada e apresentam um relatório

Por que isto funciona:

• o processo filho obtém uma janela de contexto nova
• pode gerar muitos resultados intermédios da ferramenta
• apenas a síntese final volta para o processo pai

Esta é uma das formas mais fáceis de manter uma sessão principal útil por mais tempo.

As Regras Práticas da Sessão

Se quiseres um manual compacto, usa isto:

Regra 1: Nova tarefa, nova sessão

Relacionado não é o mesmo que igual.

Regra 2: Ramo errado, volta atrás

Não acumule correções num caminho falhado se esse caminho já for ruído.

Regra 3: A mesma tarefa, contexto inchado, compacta com uma dica

Não esperes pela autocompactação se já sabes o que deve sobreviver.

Regra 4: Se o próximo passo for ruidoso, usa um subagente

Mantém o contexto pai para decisões, não para esgotamento.

Regra 5: Um contexto maior significa menos reinicializações forçadas, não nenhuma reinicialização

O contexto de 1M é uma verdadeira melhoria. Não é imunidade.

O que o contexto de 1M realmente mudou

A janela de 1M mudou a economia da gestão de sessões de três maneiras:

1. menos compactações forçadas
2. mais espaço para tarefas coerentes mais longas
3. mais tempo para compactar proativamente antes que as coisas fiquem desorganizadas

Não alterou a necessidade de:

• começar do zero em novas tarefas
• reverter ramos ruins
• evitar arrastar depurações obsoletas por trabalhos não relacionados
• enviar trabalho ruidoso para subagentes

O maior equívoco após o lançamento do contexto 1M foi «Agora posso manter tudo numa única sessão.» Tecnicamente, sessões mais longas são possíveis. Operacionalmente, continuas a querer limites mais claros do que isso.

/usage e O que observar

A Anthropic diz que o novo comando «/usage» surgiu a partir de conversas com clientes sobre sessões de longa duração e a nova janela de 1M. Isso encaixa no problema real: a maioria dos utilizadores não precisa apenas de mais contexto, precisa de uma melhor visibilidade sobre como o está a usar.

Para as decisões do dia-a-dia, presta atenção a três coisas:

• se a tarefa atual ainda é a mesma
• se o contexto atual ainda está a ajudar
• se o próximo passo precisa de resultados intermédios detalhados ou apenas da conclusão

Isso é mais prático do que ficar obcecado apenas com contagens brutas de tokens.

Um ciclo de hábitos de contexto melhor

Usa esta sequência durante um dia de trabalho real:

1. começa uma sessão com uma tarefa clara
2. continua enquanto o contexto atual ainda for útil
3. recuar quando uma ramificação der errado
4. compacta nas mudanças naturais de fase, com uma dica
5. limpa quando a tarefa mudar
6. criar subagentes para tarefas secundárias ruidosas

Esse é o modelo operacional.

Um teste de decisão de 30 segundos

Quando não tiveres a certeza do que fazer a seguir, faz três perguntas:

1. Esta ainda é a mesma tarefa?
2. O contexto atual ainda está a ajudar mais do que a prejudicar?
3. Vou precisar do resultado intermédio do próximo passo mais tarde?

Se as respostas forem:

• sim / sim / sim -> continua
• sim / não / sim -> compacta
• sim / sim / não -> subagente
• não / não / talvez -> limpar e reiniciar

Isso geralmente é suficiente para tomar a decisão certa sem pensar demais.

Fontes

• Usando o Claude Code: gestão de sessões e contexto de 1M
• Subagentes - Documentação do Claude

Páginas relacionadas

• Janela de contexto de 1M no Claude Code
• Gestão do buffer de contexto
• Engenharia de contexto
• Contexto de Início Dinâmico