Como manter o padrão das suas notas quando o Claude Code escreve por você?

Cada nota nova sai com um layout diferente, e não adianta culpar o agente

Ele não tem como adivinhar que no teu cofre o campo <code>status</code> vem antes de <code>tags</code>, que tag é sempre no singular, que a data é sempre no formato ISO e que toda nota abre com um resumo de duas linhas antes do primeiro subtítulo

Isso tudo mora na tua cabeça, e o que mora na tua cabeça não chega no contexto

A boa notícia é que existe um lugar previsível pra escrever isso: o <code>CLAUDE.md</code>, um arquivo markdown em texto puro, com instruções persistentes, que o Claude lê no início de cada sessão

É o mesmo raciocínio de um <code>.editorconfig</code> ou de um guia de estilo do time: se você conhece esses, o <code>CLAUDE.md</code> é bem semelhante, só que escrito em português mesmo, em frases normais

Se você ainda tá explorando o que dá pra fazer no cofre, vale ver os casos de uso do Claude Code no Obsidian antes de apertar o formato

Aqui a gente vai no formato: como registrar a convenção, como separar regra por tipo de nota e o que revisar quando ele escapa do padrão

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

O que você precisa antes de começar

Nada de PC da Nasa aqui, é tudo texto 🙂

• Claude Code instalado e rodando na pasta do projeto de notas, não em uma pasta qualquer: o arquivo de projeto é lido a partir dali
• Uma nota que você considera perfeita, aquela que representa o padrão que você quer. Ela vai ser copiada literalmente pra dentro da regra, então escolha uma que tenha frontmatter completo e as seções na ordem certa
• A decisão de escopo, que é o passo que a maioria pula

O Claude Code tem locais distintos de <code>CLAUDE.md</code>, em hierarquia, com escopos diferentes:

Padrão de nota é convenção do cofre, então na maioria dos casos o lugar certo é <code>./CLAUDE.md</code>

Tome cuidado com tutorial velho: existe também o <code>./CLAUDE.local.md</code>, e ele está descontinuado. Se você achar um passo a passo mandando criar esse arquivo, o material é antigo

Passo a passo para o Claude Code seguir o seu template de nota

1. Gere um <code>CLAUDE.md</code> de partida com <code>/init</code>

Dentro da sessão, na pasta do cofre:

<pre><code>/init</code></pre>

O <code>/init</code> analisa o projeto e escreve um <code>CLAUDE.md</code> de partida a partir da estrutura que encontrou

Ele é um ponto de partida pra refinar depois, não a versão final

O erro comum deste passo: rodar o <code>/init</code>, olhar o arquivo gerado, achar bonitinho e não editar nada. O arquivo que sai dali descreve a estrutura, não a TUA convenção de frontmatter

2. Escreva a convenção em texto e cole um exemplo completo

Aqui é onde o post inteiro se resolve, beleza?

Abra o <code>./CLAUDE.md</code> e escreva os campos obrigatórios, o vocabulário de tags e o esqueleto do template. E aí cole uma nota inteira, do jeito que ela tem que sair

<pre><code>## Padrão das notas

Toda nota em notas/ segue este formato, sem exceção.

Frontmatter obrigatório, nesta ordem: title, date, status, tags

• date no formato AAAA-MM-DD
• status aceita apenas: rascunho, revisar, pronto
• tags sempre no singular e em minúsculo, do vocabulário fixo:

ia, dev, carreira, ferramenta, leitura

Corpo: resumo de duas linhas, depois "## Contexto", "## Pontos principais" e "## Próximos passos".

Exemplo de nota no padrão (copie a estrutura, troque o conteúdo):

— title: Hooks no Claude Code date: 2026-08-10 status: rascunho tags: [ia, ferramenta] —

Anotação sobre validar arquivo escrito por agente. Saiu de uma leitura da documentação de hooks.

Contexto

Pontos principais

Próximos passos</code></pre>

Repare que o exemplo faz o trabalho pesado

O erro comum deste passo: descrever o padrão em abstrato ("use frontmatter YAML consistente com tags relevantes") em vez de mostrar o arquivo pronto. Instrução vaga vira interpretação criativa, e interpretação criativa é exatamente o problema que você tá tentando resolver

3. Separe regra por tipo de nota em <code>.claude/rules/</code>

Se o cofre tem tipos diferentes (nota de leitura, nota de reunião, nota diária), jogar tudo num arquivo só vira uma sopa

Dá pra dividir as instruções em arquivos dentro do diretório <code>.claude/rules/</code>, e o campo <code>paths</code> no frontmatter YAML limita a regra aos arquivos que casam com os padrões informados

<pre><code>— paths: – "notas/leituras/**/*.md" —

# Nota de leitura

Além do frontmatter padrão, inclua os campos: autor, fonte (URL ou livro) e citacao_chave.

A seção "## Pontos principais" vira "## O que ficou".</code></pre>

O erro comum deste passo: mandar pra regra com escopo justamente a convenção que não pode falhar nunca. Guarde no <code>.claude/rules/</code> o detalhe de cada tipo, e mantenha o essencial (o frontmatter obrigatório) no <code>CLAUDE.md</code> do projeto. Já já eu explico o porquê disso na seção de problemas

4. Use <code>@caminho</code> pra importar, sabendo o que isso faz (e o que não faz)

O <code>CLAUDE.md</code> pode importar outros arquivos com a sintaxe <code>@caminho</code>

<pre><code>## Padrão das notas

@docs/padrao-de-nota.md @docs/vocabulario-de-tags.md</code></pre>

Ótimo pra organização: o arquivo principal fica limpo e cada convenção vive no seu lugar

O erro comum deste passo: achar que dividir economiza contexto. Não economiza. Os arquivos importados são carregados na abertura da sessão, então o custo continua lá, só que arrumado

5. Confira o que está valendo com <code>/memory</code>

Dentro da sessão:

<pre><code>/memory</code></pre>

O <code>/memory</code> abre os arquivos de memória pra leitura e edição sem sair do Claude Code, e também dá acesso à pasta de auto memory

É o comando de "me mostra o que você acha que são as regras", e é a primeira coisa a rodar quando o resultado sai estranho

O erro comum deste passo: editar o <code>CLAUDE.md</code> e nunca conferir o conjunto. Você lembra do que escreveu, mas não necessariamente do que o Claude anotou por conta própria

6. Valide cada arquivo escrito com um hook <code>PostToolUse</code>

Instrução em texto é combinação, não garantia

Pra ter checagem de verdade, existe o evento <code>PostToolUse</code> com o matcher <code>Edit|Write</code>, que roda depois de toda escrita ou edição de arquivo e serve pra validar ou formatar o resultado

O hook recebe <code>tool_input</code> e <code>tool_response</code>, e o caminho do arquivo editado pode ser extraído dali (o exemplo da documentação usa <code>jq</code>) e passado pra uma ferramenta externa, como o Prettier

No nosso caso a ferramenta externa é um validador de frontmatter seu:

<pre><code>#!/bin/bash # valida-nota.sh # le o JSON do hook na entrada padrao e pega o caminho do arquivo arquivo=$(jq -r ‘.tool_input.file_path’)

case "$arquivo" in notas/.md) ;; *) exit 0 ;; esac

if ! head -n 1 "$arquivo" | grep -q ‘^—$’; then echo "Nota sem frontmatter: $arquivo" &gt;&amp;2 exit 2 fi

for campo in title date status tags; do if ! grep -q "^$campo:" "$arquivo"; then echo "Campo obrigatorio ausente ($campo): $arquivo" &gt;&amp;2 exit 2 fi done</code></pre>

Aí é só registrar esse script no evento <code>PostToolUse</code> com o matcher <code>Edit|Write</code>, nas configurações do Claude Code

O erro comum deste passo: esperar que o hook desfaça a escrita. Quando o <code>PostToolUse</code> dispara, a ferramenta já executou. O que ele faz é avisar: saindo com código 2, o conteúdo do <code>stderr</code> chega ao Claude como aviso, e aí ele tem a chance de corrigir o arquivo

É por isso que a mensagem de erro do script tem que dizer O QUE faltou, e não só "nota inválida"

Quando ele escapa do padrão: o que revisar

Sintoma: a regra em <code>.claude/rules/</code> parece não valer

Você criou o arquivo com <code>paths</code> no frontmatter, o caminho da nota casa com o padrão e mesmo assim o formato sai diferente, sem nenhuma mensagem de erro na tela

Causa provável: há relatos abertos no repositório oficial anthropics/claude-code de que o <code>paths</code> no frontmatter de regras em <code>~/.claude/rules/</code> é ignorado, e de que regras com escopo de caminho em <code>.claude/rules/</code> não carregam automaticamente, tudo isso em silêncio

O que revisar: abra o <code>/memory</code> e veja se aquela regra aparece entre os arquivos que estão valendo na sessão

Como prevenir: convenção crítica (os campos obrigatórios do frontmatter, o vocabulário de tags) fica no <code>CLAUDE.md</code> do projeto. O <code>.claude/rules/</code> você usa pro detalhe de cada tipo de nota, aquilo que, se falhar, dá pra ajustar na mão sem dor

Sintoma: uma instrução antiga continua sobrevivendo

Você tirou a regra do <code>CLAUDE.md</code>, mas o comportamento velho volta do nada

Causa provável: além do <code>CLAUDE.md</code> que você escreve, existe a auto memory, com notas que o próprio Claude registra a partir das suas correções e preferências. Ela fica por repositório git em <code>~/.claude/projects/</code> e vem ligada por padrão

O que revisar: o <code>/memory</code> também dá acesso à pasta de auto memory, então é lá que você vê a anotação que ele fez sozinho

Como prevenir: se você prefere que só valha o que está escrito por você, o toggle de auto memory dentro do <code>/memory</code> desliga o recurso, gravando <code>autoMemoryEnabled</code> em <code>~/.claude/settings.json</code>

Sintoma: o índice cresceu e o começo da sessão ficou desalinhado

O arquivo de índice virou um monstro, e as regras que você escreveu lá no meio não parecem estar valendo

Causa provável: só um trecho do índice <code>MEMORY.md</code> entra no contexto no início da sessão: as primeiras 200 linhas ou 25 KB

O que revisar: o tamanho do índice e o que ficou pra baixo desse corte

Como prevenir: trate o começo do índice como área nobre. O que precisa valer sempre não pode estar lá no fim do arquivo

Sintoma: o padrão muda dependendo da worktree

Você trabalha em worktrees separadas do mesmo repositório e as notas saem inconsistentes entre elas

Causa provável: todas as worktrees de um mesmo repositório apontam pra um único diretório de auto memory. Ou seja, a anotação feita em uma vale nas outras

O que revisar: o que foi registrado ali, via <code>/memory</code>, lembrando que é um lugar só e não um por worktree

Como prevenir: convenção de formato mora em arquivo versionado, no <code>./CLAUDE.md</code>, que viaja junto com o repositório e não depende de memória automática

Juntando tudo num quadro rápido:

Quem decide o padrão ainda é você

Tem uma parte disso tudo que nenhum arquivo de configuração resolve: escolher qual é o formato certo pro teu jeito de pensar

Pra começar do zero nessa parte, esse vídeo do canal fala sobre tomar as próprias decisões como dev, o critério antes do atalho

Decidir o padrão é teu, executar o padrão é do agente 😀

Conclusão

Convenção que não está escrita no projeto não é seguida, e ponto

O <code>CLAUDE.md</code> é lido no início de cada sessão, o <code>.claude/rules/</code> separa regra por tipo de nota com o campo <code>paths</code>, o <code>/memory</code> mostra o que está valendo e o hook <code>PostToolUse</code> com matcher <code>Edit|Write</code> checa o resultado depois que o arquivo foi escrito

O próximo passo é bem objetivo: abra aquela nota que você acha perfeita, transcreva o formato dela pro <code>CLAUDE.md</code> (frontmatter inteiro, tags, seções na ordem) e peça a próxima nota pedindo que ele siga esse arquivo

Aí é só comparar as duas lado a lado e ver o que ainda escapou…

até o próximo post!