Quando abrir uma conversa nova no Claude Code (e quando só compactar a atual)?

Fala aí, beleza? Existe um momento exato em que a conversa do Claude Code para de ajudar e começa a atrapalhar

Você pede uma coisa e ele volta com aquela abordagem que você descartou três mensagens atrás

Ou o assunto mudou de rumo no meio do dia, você saiu do bug de autenticação e foi pro deploy, só que o histórico velho continua ali, sendo recobrado a cada mensagem nova

Na maioria dessas vezes o problema não é o modelo, é o histórico

E aí a decisão não é trocar de ferramenta, é gestão de contexto: limpar, compactar ou ramificar

Bora ver quando abrir uma conversa nova no Claude Code, quando só compactar a atual e, principalmente, o que levar junto pra não jogar fora o que já foi feito

O que você precisa saber antes de decidir

O que é uma sessão, afinal?

Uma sessão é uma conversa salva, vinculada ao diretório do projeto e guardada localmente enquanto você trabalha

É isso que permite retomar depois, ramificar pra testar outra abordagem ou alternar entre tarefas

Se você conhece branch de Git, a ideia de ramificar aqui vai soar bem familiar 🙂

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

Janela cheia não é fim de conversa

O Claude Code compacta automaticamente conforme a sessão se aproxima do limite

Ou seja: encher a janela não encerra a sessão, ela se ajusta sozinha

E tem um detalhe que confunde muita gente: Fable 5, Sonnet 5, Opus 4.6 em diante e Sonnet 4.6 suportam janela de 1 milhão de tokens pra sessões longas em bases grandes, mas dentro do Claude Code o modelo é tratado como tendo 200 mil tokens

Com a auto-compactação ligada, as sessões compactam nessa fronteira de 200 mil

Então a pergunta prática nunca é "cabe mais?", é "o que está ocupando esse espaço?"

Como enxergar isso ao vivo

/context

Esse comando mostra um detalhamento ao vivo do uso da janela por categoria, com sugestões de otimização

Inclusive quais arquivos CLAUDE.md e de auto memory foram carregados

Se você quiser ir fundo em outro ajuste que muda o comportamento do agente, eu já escrevi por aqui sobre extended thinking no Claude Code

Como decidir na prática: o passo a passo da conversa nova

1. Leia a janela antes de agir

Rodar /context primeiro evita decisão no chute

Você vê por categoria o que está pesando, e já descobre se o problema é histórico velho ou memória carregada demais

O erro comum deste passo: limpar por reflexo, sem olhar

2. Aplique a régua das mais de duas correções

Essa é a régua oficial da documentação, e é a mais útil de todas

Se você corrigiu o Claude mais de duas vezes sobre o mesmo ponto na mesma sessão, o contexto está entulhado de abordagens que falharam

Nesse caso, rodar /clear e recomeçar com um prompt mais específico quase sempre supera continuar a sessão longa com correções acumuladas

O erro comum deste passo: insistir na correção número quatro achando que agora vai

3. Trocou de tarefa não relacionada? Limpa

/clear

O /clear reseta a conversa para um contexto vazio: os prompts seguintes começam sem nenhum histórico anterior

A própria documentação recomenda usar isso com frequência entre tarefas não relacionadas, porque sessões longas com contexto irrelevante reduzem o desempenho

Tem o lado da conta também: contexto velho é recobrado a cada mensagem, e limpar corta esse desperdício, o que faz diferença pra quem acompanha quanto o Claude Code custa hoje

E calma, limpar não destrói nada: a conversa anterior continua salva em disco e pode ser retomada depois pelo ID da sessão

O erro comum deste passo: achar que /clear apaga a conversa pra sempre e por isso nunca usar

4. Mesma tarefa, histórico longo? Compacta com foco

/compact focus on the auth bug fix

O /compact reduz o histórico resumindo mensagens antigas em vez de apagá-las

E ele aceita instrução de foco, pra você escolher o que o resumo preserva em vez de deixar a passagem automática adivinhar

Detalhe: ele exige uma conversa já existente, com trocas anteriores, pra ter o que resumir

O erro comum deste passo: rodar /compact seco e depois descobrir que justo o pedaço que importava virou uma linha genérica

5. Quer cortar só um trecho? Volta no checkpoint

Aperta Esc duas vezes ou roda:

/rewind

Abre o menu de checkpoints com quatro opções: restaurar a conversa (mantendo o código), restaurar o código (mantendo a conversa), resumir dali em diante e resumir até ali

Os checkpoints são salvos junto da conversa, então dá pra fechar o terminal, retomar a sessão depois e ainda usar o /rewind

O erro comum deste passo: confundir restaurar conversa com restaurar código, são coisas diferentes e o menu deixa isso explícito

6. Ajuste quando a compactação automática dispara

/autocompact

Esse comando define, por contagem de tokens, o quão cheia a janela fica antes da compactação automática rodar

O erro comum deste passo: mexer nisso antes de entender o que está ocupando a janela (volta pro passo 1!)

7. Voltar ou ramificar sem escrever por cima

/resume

O /resume retoma uma conversa por ID, por nome, ou abre o seletor de sessões, e o /continue é um apelido dele

Pela linha de comando dá pra combinar com fork, retomando sem escrever por cima da sessão original:

claude --continue --fork-session
claude --resume --fork-session

E tem o caminho de dentro da conversa:

/branch

Ele cria uma ramificação da sessão e a confirmação imprime dois IDs, o da ramificação nova e o da original

A original fica intacta no disco e continua aparecendo no seletor de sessões

O erro comum deste passo: retomar direto na sessão original pra "testar uma ideia" e sujar justamente a conversa que estava boa

O que levar junto para não recomeçar do zero de verdade

A parte que dói no /clear não é perder o histórico, é perder o combinado

Aquele detalhe do projeto que você explicou três vezes e não quer explicar de novo

Se liga no que sobrevive à conversa:

1. Instrução persistente vai pro CLAUDE.md

Os arquivos CLAUDE.md são markdown com instruções persistentes para o projeto, pro seu fluxo pessoal ou pra organização

Ou seja: eles sobrevivem ao fim da conversa, é exatamente pra isso que servem

2. Use os gatilhos oficiais pra escrever nele

A documentação indica escrever no CLAUDE.md quando:

• o Claude comete o mesmo erro pela segunda vez
• você digita a mesma correção que já digitou na sessão passada
• um colega novo precisaria do mesmo contexto pra entender aquilo

O erro comum deste passo: corrigir de novo no chat e seguir a vida, aí a correção morre junto com a sessão

3. Ensine a compactação a preservar o que importa

Dá pra customizar o comportamento da compactação pelo próprio CLAUDE.md, com instruções do tipo preservar sempre a lista completa de arquivos modificados e os comandos de teste

É o mesmo espírito do foco no /compact, só que valendo por padrão

4. Deixe a auto memory trabalhar

A auto memory acumula conhecimento entre sessões sem você escrever nada: o Claude salva notas próprias, tipo comandos de build, achados de depuração, notas de arquitetura, preferências de estilo e hábitos de fluxo

Pra ver o que foi salvo:

/memory

Daí é só selecionar a pasta de auto memory

É tudo markdown, dá pra ler, editar ou apagar na mão

5. Pode sem dó

Aqui vai o contraponto, porque mais nem sempre é melhor

Um CLAUDE.md superespecificado atrapalha: regra importante se perde no ruído

A orientação é podar, apagando o que o Claude já faz certo sem ser mandado, ou convertendo aquela regra em hook

O erro comum deste passo: transformar o CLAUDE.md num manual gigante e depois reclamar que ele ignora a regra que interessa

Quatro situações e o comando certo para cada uma

O assunto trocou no meio do dia:

Você estava no bug de autenticação e agora vai mexer no deploy

Nada do histórico anterior ajuda, e ele é recobrado a cada mensagem

É /clear, sem drama, a conversa antiga continua em disco e volta pelo ID quando você precisar

O agente insiste numa abordagem que você já descartou:

Contou quantas correções? Passou de duas sobre o mesmo ponto?

Então o contexto está entulhado de tentativas que falharam

/clear e reescreve o prompt mais específico, já dizendo o caminho que NÃO é pra seguir

A tarefa é longa e você só quer enxugar o histórico:

Aqui limpar seria burrice, você perderia o fio da meada

/compact com instrução de foco resolve, resumindo o antigo em vez de apagar

E se o problema for um trecho específico, /rewind deixa você resumir até ali ou dali em diante

Você quer testar um segundo caminho sem perder o primeiro:

/branch cria a ramificação e imprime os dois IDs, com a original intacta no seletor

Pela linha de comando, --fork-session junto de --continue ou --resume faz o mesmo papel de não escrever por cima

E o subagente, entra onde?

Esse é o truque que pouca gente usa: cada subagente roda na própria janela de contexto, com system prompt próprio, acesso a ferramentas específico e permissões independentes

O contexto dele começa do zero, sem a conversa do pai

O único conteúdo que passa do pai pro subagente é o texto do prompt da ferramenta Agent, e só a mensagem final dele volta pra conversa principal (as chamadas e resultados intermediários ficam lá dentro)

Traduzindo: é uma forma de investigar coisa pesada sem sujar a conversa principal 😀

O que a prática mostra sobre trocar de conversa

Aqui entra a parte que eu vivi, não a que eu li

No vídeo abaixo eu mostro o painel de sessões do Claude Code, e ele mexeu justamente com a decisão de quando abandonar uma conversa e abrir outra

Antes de existir esse painel, pra rodar mais de uma conversa no mesmo projeto eu precisava abrir dois ou mais terminais

E ficava alternando entre eles só pra descobrir se a tarefa já tinha terminado

Esse vai e volta custava tempo, e gerenciar as sessões ficava difícil

Na demonstração eu abri uma conversa nova pra cada tarefa diferente do sistema: uma pra criar a estrutura de autenticação, outra pra outra ação

Em vez de empilhar as duas na mesma conversa, que é exatamente o hábito que enche a janela de contexto irrelevante

O painel mostra quantas sessões estão esperando resposta minha, quantas estão trabalhando e quantas já terminaram, cada estado com uma cor, e eu navego entre elas com as setas

Dá até pra mandar mensagem pra uma sessão já existente sem abrir a conversa, e eu usei isso pra pedir uma revisão do que tinha sido feito

Quando uma conversa fica parada e eu não vou mais usar, eu excluo a sessão e começo um recurso novo do zero em outra

Teve uma tarefa que eu achei que ia demorar, escrever testes pra aplicação, e essa eu joguei pro segundo plano em vez de ficar supervisionando, liberando o terminal pra outra coisa

É esse o uso que eu faço na prática: sessões paralelas pra revisão de segurança, performance e criação de testes, porque essas não atrapalham diretamente a evolução do projeto

Agora, sinceridade: eu não sou do tipo que abre quinze terminais programando ao mesmo tempo

Pra mim isso ainda não funciona, exigiria uma confiança na IA que eu não tenho

O recurso não é complexo, ele resolve um problema bem específico, e é justamente por isso que ele muda a rotina

Conclusão

A régua enxuta pra guardar:

E o próximo passo é agora mesmo, na sessão que você já tem aberta aí

Roda /context e olha o que está ocupando a janela

Se você identificar uma correção que já repetiu, move ela pro CLAUDE.md ANTES de limpar, senão você vai digitar a mesma coisa de novo amanhã

Depois disso, limpar sai barato e a conversa nova nasce sabendo o que precisa saber

Faça o teste e me conta como foi, até o próximo post!