Por que o Claude Code ignora a instrução que você deu duas mensagens atrás?

Fala aí, beleza? Tu combinou uma regra com o Claude Code, ele seguiu certinho por dois turnos, e no terceiro voltou pro comportamento antigo como se a conversa nunca tivesse acontecido

E aí bate aquela sensação de estar repetindo a mesma frase pra parede 😅

Só que tem duas coisas MUITO diferentes acontecendo aqui, e elas se resolvem de jeitos opostos: ou a instrução saiu do contexto (esquecimento real), ou ela nunca foi clara o bastante pra ser seguida (instrução ambígua, brigando com outra)

Neste post eu separo uma da outra por sintoma, e mostro onde a regra tem que morar pra valer o tempo todo, e não só nos dois turnos seguintes

Bora?

Sintoma 1: a instrução funcionou e parou depois de uma conversa longa

Esse é o clássico

Tu pede algo no começo da sessão, ele obedece por um bom tempo, a conversa cresce, e do nada o comportamento antigo volta

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

A causa: compactação

Quando a sessão fica longa demais pro contexto, o Claude Code compacta o histórico

O processo tem ordem: primeiro ele limpa saídas de ferramenta antigas, depois resume o que sobrou

Os seus pedidos e trechos de código importantes são preservados nesse resumo

Mas instrução detalhada dita lá no começo pode simplesmente sumir na síntese

Ou seja: não é teimosia, é que aquele texto não existe mais na conversa que ele está lendo agora

A solução: tirar a regra do chat e botar no disco

O CLAUDE.md da raiz do projeto sobrevive à compactação

Depois do /compact, o Claude relê esse arquivo do disco e reinjeta na sessão

Então a regra que tu quer que valha do começo ao fim da sessão vai pra lá, e não pra uma mensagem solta

Dá pra controlar o que a compactação preserva de duas formas: com uma seção de instruções de compactação (Compact Instructions) dentro do CLAUDE.md, ou rodando o /compact com um foco:

/compact focus on the API changes

E dá pra mexer no gatilho também, definindo quanto o contexto enche antes da passada automática:

/autocompact 500k

Pra prevenir: nem todo arquivo volta

Se liga nisso, porque essa parte pega muita gente

CLAUDE.md aninhado em subpasta e regra com frontmatter paths: NÃO são reinjetados automaticamente depois da compactação

Eles só voltam quando o Claude ler de novo um arquivo daquela subpasta, ou um arquivo que case com o padrão da regra

Então se a tua convenção mais importante está enterrada num src/api/CLAUDE.md, ela tem uma janela pra sumir e não voltar sozinha

A documentação de memória do Claude Code detalha esses níveis e como cada um é carregado: code.claude.com/docs/en/memory

Sintoma 2: ele lembra do primeiro e do último pedido, mas ignora o do meio

Esse é mais sutil

Tu olha a conversa, a instrução está lá, escrita, legível, no meio do papo

E mesmo assim ele age como se só existisse o que tu falou no início e o que tu acabou de mandar

A causa: perda nos turnos do meio

Tem estudo sobre isso, não é achismo

O paper LLMs Get Lost In Multi-Turn Conversation mediu queda média de 39% no desempenho em conversas multi-turno comparadas com turno único, em seis tarefas de geração

O fenômeno tem nome: loss-in-middle-turns

O modelo ajusta demais a resposta com base no primeiro e no último turno da conversa, e negligencia a informação que ficou no meio

E a conclusão mais dura do estudo é essa: quando o modelo pega o caminho errado numa conversa, ele se perde e não se recupera sozinho

Continuar mandando "não, eu falei pra fazer diferente" no mesmo fio tende a piorar, não a corrigir

A solução: encerrar o fio, não empurrar

• /clear entre tarefas não relacionadas, pra não arrastar meia hora de assunto morto
• delegar pesquisa a subagentes, mantendo a conversa principal limpa
• se a regra vale só pra esta tarefa, ela pode ser mensagem mesmo

Pra prevenir: a régua é a validade da regra

A pergunta que resolve a maior parte dos casos é simples

Essa regra vale amanhã também?

Se vale, ela vira arquivo

Se é só pra este pedido, mensagem serve

Mensagem no chat é combinado temporário, e ele expira sem avisar

Se tu está montando o teu jeito de trabalhar do zero, vale ver o fluxo completo de um projeto pra entender onde cada tipo de decisão encaixa

Sintoma 3: são regras demais e ele cumpre só algumas

Aqui o CLAUDE.md está lá, bonitão, completão

Com regra pra tudo quanto é canto

E ele cumpre uma parte, ignora outra, sem tu conseguir prever qual

A causa: densidade de instruções

O benchmark IFScale mede exatamente isso: o que acontece com a aderência conforme a densidade de instruções cresce, usando até 500 instruções de inclusão de palavra-chave

O resultado é meio brutal: mesmo os melhores modelos de fronteira chegam a apenas 68% de acurácia na densidade máxima de 500 instruções

O estudo identificou três padrões distintos de degradação, ou seja, três FORMATOS de curva que a queda pode assumir:

• decaimento por limiar: desempenho quase perfeito até uma densidade crítica, e depois variância crescente
• decaimento linear
• decaimento exponencial

E observou um viés a favor das instruções que vieram antes

Agora presta atenção nesta parte, porque é fácil se enrolar: são estudos diferentes, medindo coisas diferentes

O IFScale cataloga o formato da curva de cada caso (tem caso que desce reto, tem caso que despenca), enquanto o benchmark Instruction Stacking Collapse olha a taxa de cumprimento no agregado, conforme a contagem de instruções sobe

Esse segundo benchmark empilha instruções verificadas por verificador, de uma a vinte por vez, em três LLMs de produção, e chega numa conclusão na mesma direção: a aderência degrada de forma NÃO linear conforme a contagem de instruções sobe

Não linear aqui quer dizer que o custo não é fixo por regra

A regra número 30 não custa o mesmo que a número 3

A solução: cortar, sem dó

O CLAUDE.md é carregado por inteiro, independente do tamanho

Mas arquivo mais curto produz aderência melhor, e a recomendação oficial é manter cada CLAUDE.md abaixo de 200 linhas, justamente porque arquivo maior consome mais contexto e derruba a aderência

Então a pergunta não é "o que mais eu posso escrever aqui"

É "o que aqui dentro não precisa estar em TODA sessão"

Pra prevenir: olhe o que foi carregado de verdade

O comando /context mostra uma quebra ao vivo do uso do contexto por categoria, com sugestões de otimização, incluindo quais arquivos CLAUDE.md e de auto memory foram carregados

Vale rodar antes de sair culpando o modelo, sério

Muita "instrução ignorada" é instrução que nem entrou

Sintoma 4: a regra está escrita e mesmo assim não é seguida

Agora a gente sai do esquecimento e entra na ambiguidade

Esse sintoma é diferente dos outros três: a instrução ESTÁ no contexto, tu confirmou no /context, e ainda assim ele faz outra coisa

A causa: dois arquivos falando coisas diferentes

Os arquivos CLAUDE.md existem em níveis de escopo

Tem o de managed policy, o de usuário em ~/.claude/CLAUDE.md e o de projeto em ./CLAUDE.md

Os caminhos de managed policy mudam por sistema operacional:

E aqui está o ponto que quase ninguém percebe: esses níveis são ADITIVOS, e não existe regra dura de precedência entre eles

Quando duas instruções conflitam, o resultado depende de como o Claude interpreta

Ou seja: tu escreveu "sempre commitar ao terminar" no arquivo do projeto e "nunca commitar sem eu pedir" no arquivo de usuário, e agora está no chute

Não é esquecimento, é empate

A solução: resolver o conflito no papel

A orientação é escrever regras não conflitantes, ou declarar a precedência explicitamente no arquivo mais específico

Ou seja, se o projeto manda mais que o teu arquivo pessoal naquele ponto, escreva isso, com todas as letras, dentro do arquivo do projeto

Se o problema é um arquivo inteiro que não deveria estar entrando, existe o claudeMdExcludes

Ele pode ser definido em qualquer camada de settings (usuário, projeto, local ou managed policy) e os arrays são mesclados entre as camadas

Uma ressalva importante: CLAUDE.md de managed policy não pode ser excluído

E quando quem briga com você é a memória automática?

O Claude Code tem dois sistemas de memória complementares

Os arquivos CLAUDE.md, que tu escreve

E a Auto memory, que são notas que o próprio Claude salva

Os dois são carregados no início de toda conversa, então uma nota antiga salva por ele pode estar contradizendo a regra que tu acabou de escrever

O comando /memory abre a memória dentro da sessão e deixa navegar a pasta de auto memory, que é markdown puro: dá pra ler, editar ou apagar na mão

O mesmo /memory tem o toggle de auto memory, que grava autoMemoryEnabled nas configurações do usuário em ~/.claude/settings.json

Antes de reescrever a tua regra pela quinta vez, dá uma lida no que ele anotou sobre você 👀

Onde colocar cada tipo de regra para ela valer o tempo todo

Beleza, e o mapa prático?

A régua oficial é por FREQUÊNCIA de uso, não por importância

A regra modular fica assim:

---
paths:
  - "src/components/**/*.tsx"
---

Componente novo sempre com tipagem explícita das props

Sem o paths:, ela carrega no começo da sessão

Com o paths:, ela só entra quando um arquivo que casa com o glob aparece no contexto

E subdiretórios são descobertos automaticamente, então .claude/rules/frontend/react.md funciona sem tu registrar nada

Massa, né? Isso resolve o Sintoma 3 de graça: tu tira do CLAUDE.md tudo que é situacional e o arquivo principal encolhe

E se eu quiser injeção garantida em toda mensagem?

Existe esse caminho, mas ele tem um preço

O hook UserPromptSubmit roda toda vez que tu envia um prompt, antes do Claude processar

Ele permite injetar contexto pelo campo additionalContext, que entra como system reminder e é lido como texto puro

O detalhe que dói: ele BLOQUEIA o processamento até terminar, e tem timeout padrão de 30 segundos, bem menor que os 600 segundos padrão da maioria dos outros eventos

Então isso não é lugar pra script lento

Tome cuidado: cada mensagem tua passa por ali

Conclusão: o que fazer na próxima vez que ele ignorar a regra

A régua que fecha tudo é essa

Mensagem no chat é combinado temporário

Arquivo é combinado permanente

O Claude Code não está sendo teimoso quando ignora instruções: ou o texto saiu do contexto (compactação, turno do meio), ou ele está no meio de um empate que você não desempatou

Na próxima vez que acontecer, faz nesta ordem:

1. Rode /context pra ver o que foi realmente carregado, por categoria, incluindo quais CLAUDE.md e arquivos de auto memory entraram. O erro comum aqui é pular esse passo e reescrever a regra que já estava lá, só que perdida no meio de um monte de outras
2. Mova a regra que se perdeu pro CLAUDE.md da RAIZ do projeto, que é o que é reinjetado depois da compactação. O erro comum: deixar ela num CLAUDE.md de subpasta e achar que está resolvido, quando aninhado não volta sozinho
3. Corte o arquivo pra ficar abaixo de 200 linhas, que é a recomendação oficial. O erro comum é confundir "carregado por inteiro" com "seguido por inteiro": ele lê tudo, mas a aderência cai conforme a densidade sobe
4. Mande o resto pro lugar certo: regra por tipo de arquivo vai pra .claude/rules/ com paths:, e conteúdo eventual vira skill acionada por comando

E se depois disso a regra continuar sendo ignorada, aí é hora de checar o /memory e ver se tem uma nota antiga discordando de você

Faça o teste! Na maioria das vezes o problema não era a regra, era o endereço dela

Até o próximo post!