Claude Code ou OpenCode: o que acontece com a sessão quando você fecha o terminal?

Fala aí, beleza? Fechar o terminal no meio de uma tarefa é fácil

Difícil é sentar no dia seguinte e descobrir se o agente ainda faz ideia do que vocês dois estavam fazendo ontem

Os dois gravam sessão, isso não é o ponto

O ponto é COMO cada um devolve o fio pra sua mão, e o que cada um cobra do seu repositório pra não começar do zero toda manhã

Aqui o recorte é rotina diária: nada de instalação, nada de preço, só o que acontece entre fechar o terminal hoje e abrir de novo amanhã 🙂

Claude Code x OpenCode: sessão, histórico e memória lado a lado

Repara numa coisa antes de descer: as duas colunas resolvem o mesmo problema, mas com quantidade de peça bem diferente

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 retomar o trabalho de ontem em cada agente

Essa é a parte que você faz todo dia de manhã, então vale decorar

1. Claude Code, o caminho preguiçoso: rode claude -c (forma longa claude --continue) na pasta do projeto e ele volta na sessão mais recente DAQUELE diretório. Como o transcript é salvo continuamente, a sessão segue retomável depois de você sair do terminal e até depois de rodar /clear. O erro comum aqui é rodar o comando na pasta errada, tipo um nível acima do repo, e achar que a sessão sumiu: ela não sumiu, você só pediu a mais recente de outro diretório
2. Claude Code, quando tem mais de uma sessão viva: use /resume de dentro da sessão ou claude --resume sem argumento pra abrir o seletor interativo. Ele mostra nome ou título, resumo da conversa, tempo desde a última atividade, branch do git e tamanho do arquivo, o que já mata metade da dúvida de qual era qual
3. Claude Code, retomada por ID: claude --resume <session-id> pode ser rodado de qualquer diretório. Ele procura o ID primeiro no projeto atual e nos worktrees do git, e só depois em todos os outros projetos da máquina
4. Nomeie o que é longo: --name na abertura ou /rename no meio substituem o título gerado. Sem nome, o título é um resumo curto do primeiro prompt, escrito por uma requisição em segundo plano ao modelo pequeno e rápido. O erro comum deste passo é confiar nesse título automático em três sessões parecidas e depois não achar a certa no seletor
5. Quer testar um caminho sem sujar a conversa boa: /branch copia o transcript e passa a escrever na cópia, e sessões criadas com /branch ou --fork-session ganham IDs próprios e aparecem como linhas separadas no seletor. A original fica intacta, é o git checkout -b da conversa
6. OpenCode, o caminho preguiçoso: opencode -c continua a última sessão direto da linha de comando
7. OpenCode, escolhendo na mão: /sessions lista e alterna entre sessões, e os apelidos /resume e /continue fazem a mesma coisa, então não precisa lembrar qual é o nome oficial
8. OpenCode sem tirar a mão do teclado: o atalho é ctrl+x l. E aqui vai a pegadinha: ctrl+x é a leader key padrão, ou seja você pressiona a leader e DEPOIS a tecla do atalho, não os três juntos

Os comandos, tudo junto pra você colar no seu bloco de notas:

# Claude Code
claude -c                      # sessão mais recente deste diretório
claude --resume                # abre o seletor interativo
claude --resume <session-id>   # de qualquer pasta
claude --name "refactor auth"  # nomeia a sessão

# OpenCode
opencode -c                    # continua a última sessão

E se o problema não foi você fechar o terminal, e sim o agente travar no meio da tarefa, a retomada tem outro roteiro

O que deixar escrito no repositório para não recomeçar do zero

Sessão salva é ótimo, mas sessão não é documentação

O que faz o agente entender o projeto de novo na largada é arquivo, e cada um lê os seus

O que o Claude Code lê ao abrir:

• CLAUDE.md e CLAUDE.local.md, carregados na janela de contexto no início de TODA sessão. Ele sobe a árvore de diretórios a partir do diretório de trabalho, checando os dois em cada nível
• imports com @caminho dentro do CLAUDE.md, que ajudam MUITO na organização mas não reduzem contexto: os arquivos importados também são carregados na largada
• /init gera um CLAUDE.md inicial, e se o repositório já tiver um AGENTS.md, o /init lê esse arquivo e incorpora as partes relevantes no CLAUDE.md gerado
• a auto memory, que é a segunda camada: notas que o próprio Claude escreve a partir das suas correções e preferências. Ela fica em ~/.claude/projects/<project>/memory/, o /memory abre a pasta pra navegar, e é tudo markdown legível e editável

Um detalhe que economiza confusão: o caminho da auto memory é derivado do repositório git, então worktrees e subdiretórios do mesmo repo compartilham um único diretório de memória

Ou seja, corrigiu o agente numa worktree, a correção vale nas outras 😀

O que o OpenCode lê ao abrir:

• AGENTS.md na raiz do projeto, com as regras daquele repositório, valendo quando você trabalha nesse diretório ou em subdiretórios dele
• ~/.config/opencode/AGENTS.md para regras globais, aplicadas em todas as sessões. Como esse arquivo não vai pro git nem é compartilhado com o time, é o lugar recomendado pras suas manias pessoais
• /init varre os arquivos importantes do repositório, pode fazer algumas perguntas dirigidas e cria ou atualiza o AGENTS.md. Se já existir um, ele MELHORA o arquivo no lugar em vez de substituir, o que é bem menos assustador de rodar em projeto vivo
• arquivos de instrução próprios apontados no campo de instructions do opencode.json do projeto ou do ~/.config/opencode/opencode.json global, todos combinados com os AGENTS.md, como explica a documentação de regras do OpenCode

A leitura prática é a mesma nos dois, e cabe numa linha: regra de time vai no arquivo versionado, regra pessoal vai no global

Se você mistura, seu colega herda o seu jeito de escrever commit e nem sabe por quê

Quando o fio se perde mesmo com a sessão salva

Acontece: a sessão está lá, retomou bonitinho, e ainda assim o agente esqueceu uma decisão que vocês tomaram de manhã

Ou seja, arquivo de sessão intacto e fio da conversa perdido são duas coisas diferentes, e é bom não misturar as duas

São três situações diferentes, com causas diferentes

O agente esquece uma decisão antiga no meio de uma sessão longa:

A causa quase sempre é compactação

No Claude Code o histórico é compactado automaticamente ao se aproximar do limite de contexto, limpando primeiro as saídas de ferramenta mais antigas e depois resumindo a conversa se necessário

No OpenCode a compactação substitui a parte mais antiga do contexto ativo por um checkpoint gerado: um resumo estruturado (objetivo, detalhes importantes, trabalho concluído e em andamento, bloqueios, próximos passos e arquivos relevantes) mais uma cauda serializada do contexto recente

A prevenção existe dos dois lados

No Claude Code você adiciona uma seção Compact Instructions no CLAUDE.md, ou roda /compact com um foco ("foca na modelagem do banco", por exemplo)

No OpenCode a compactação automática vem ligada por padrão e dispara antes da chamada do modelo quando os tokens estimados passam do limite de contexto menos a maior margem entre tokens de saída pedidos e buffer; o comportamento é configurável pela opção compaction (auto, keep.tokens, buffer) e existe o /compact manual

Se a conversa já está gigante e as respostas começaram a piorar, o assunto é sessão longa com contexto cheio, que é um problema vizinho mas não idêntico

O arquivo de memória cresceu e a parte de baixo não entra:

Esse pega muita gente de surpresa

Do MEMORY.md do Claude Code, apenas as primeiras 200 linhas ou os primeiros 25KB (o que vier primeiro) são carregados no início de toda conversa

O que passa disso não entra na largada

Então aquela regra de ouro que você escreveu na linha 340 simplesmente não existe pro agente

Tome cuidado com isso: memória boa é memória curta e no topo

Você quer voltar a um ponto anterior da conversa ou do código:

No Claude Code cada prompt enviado cria um checkpoint

Dois toques em Esc, ou o comando /rewind, abrem o menu com as opções de restaurar código e conversa, só a conversa, só o código, ou resumir a partir do ponto escolhido

No OpenCode o mecanismo são os snapshots, que rastreiam mudanças de arquivo durante a operação do agente e permitem desfazer e reverter alterações dentro da sessão

E já que estamos falando de espaço: a janela de contexto do Claude Code guarda o histórico da conversa, conteúdo de arquivos, saídas de comandos, CLAUDE.md, auto memory, skills carregadas e instruções de sistema

Tudo isso disputa o mesmo lugar, o tempo todo

O que eu vi rodando os dois no mesmo projeto

Esse post nasceu de um teste que eu gravei

Gerei um projeto completo com 4 páginas (landing, registro, login e dashboard), autenticação, banco e integração com IA

Antes de trocar de ferramenta, pedi ao próprio agente que gerasse um arquivo de documentação na raiz do projeto: visão geral, stack, estrutura de pastas, banco de dados, autenticação, como rodar, convenções e regras importantes

A ideia era um aperto de mão entre agentes, pro próximo conseguir retomar o projeto e criar coisa nova sem destruir o que já existia

E eu falo isso com honestidade: o certo seria eu ter LIDO o arquivo gerado e conferido se ficou completo

Eu não li, segui em frente assumindo que estava certo, e deu sorte 😛

Do outro lado, no OpenCode, pedi pro agente novo entender o projeto e explicar como ele funciona

A resposta descreveu o sistema corretamente: usuário escreve o produto, a IA gera slogans, histórico salvo na conta

Aí mandei 4 funcionalidades num único prompt: dark mode, favoritar slogans, copiar pra área de transferência e exportar histórico em CSV

No mesmo prompt pedi que ele atualizasse o arquivo de documentação com os novos recursos, porque documento que não reflete a fase atual do projeto vira mentira em duas semanas

Os números do teste, já que perguntam sempre: coloquei 2 dólares de crédito antes de começar, o projeto completo saiu por cerca de 11 a 12 centavos de dólar, uma execução anterior tinha marcado 3 centavos, e depois das quatro funcionalidades o consumo acumulado exibido era 15 centavos

Vale a ressalva que eu mesmo fiz na gravação: esse consumo fica um pouco mascarado, porque a própria aplicação usava a mesma chave de API dos testes

Amarrando com o tema do post: a sessão única aguentou o projeto inteiro numa boa

O que sobreviveu entre uma tarefa e outra, e principalmente na troca de ferramenta, foi o que estava ESCRITO no repositório

Uma diferença que me chamou atenção na configuração: no OpenCode a conexão com o provedor fica salva pra próxima sessão, e no Claude Code eu preferi deixar por projeto em vez de valendo pra sempre

E não é dogma, é contexto: o Claude Code já vem com modelo próprio, enquanto o OpenCode não tem modelo base e depende de conectar um provedor e escolher o modelo

O OpenCode, aliás, é agente sem interface gráfica, tudo por terminal, apesar do visual bem caprichado

No vídeo abaixo dá pra ver isso rodando de ponta a ponta, incluindo o momento em que o agente novo lê o projeto e explica o que ele faz:

Qual dos dois segura melhor o fio do projeto

Não tem vencedor absoluto aqui, tem perfil de rotina

O Claude Code brilha no controle fino da sessão

Seletor com resumo, tempo, branch e tamanho, retomada por ID de qualquer diretório, ramificação da conversa com /branch, /export legível pra humano e memória em duas camadas: a que você escreve e a que o agente escreve sozinho

Se você vive com cinco frentes abertas no mesmo repo e precisa achar A conversa certa de terça, é aqui que o dia rende

O OpenCode entrega o essencial com menos peça

Continuar a última sessão, listar e trocar, AGENTS.md na raiz mais o global pras suas regras pessoais, checkpoint estruturado quando compacta e /share com import e export em JSON

Esse último detalhe pesa mais do que parece quando a sessão precisa CIRCULAR: mandar o estado pra outra máquina, pra outra pessoa, pra outra ferramenta

Resumindo o critério: sessão como acervo que você navega puxa pro Claude Code, sessão como algo simples de continuar e fácil de passar adiante puxa pro OpenCode

Conclusão

A sessão no Claude Code e no OpenCode sobrevive ao terminal fechado nos dois casos, então o gargalo da sua manhã não é esse

O gargalo é o que está escrito, e o que cabe na largada

Seu próximo passo é curtinho: roda /init no repositório que você mais usa, nomeia as sessões longas com --name ou /rename em vez de depender do título automático, e move pro arquivo de memória as decisões que você não quer repetir amanhã

Só isso já muda a sensação de sentar na cadeira de manhã, é sério

Agora me conta nos comentários: qual dos dois virou padrão na sua rotina, e por quê?

Até o próximo post! =)