Suas notas do Obsidian “crescem sozinhas” com IA. O mecanismo do segundo cérebro

Meia-noite, e eu estava digitando na busca do Obsidian: “aquele comando, qual era mesmo?”.

Um comando de shell de três linhas que anotei dois anos atrás. Que existe, existe, disso eu tinha certeza. Mas em qual das mais de 500 notas ele estava enterrado, eu não fazia a menor ideia. No fim, naquele dia, desisti de procurar e busquei no Google de novo.

Isso não acontece só comigo, eu aposto.

O Obsidian (app de notas) fica mais útil quanto mais você usa. Mas, ao mesmo tempo, bagunça, sem falta. Log diário, nota de leitura, fragmento de código, ideia de artigo, ata de reunião. Tudo se acumula como arquivo Markdown e, em meio ano, vira “o seu ferro-velho particular, difícil de buscar”.

Foi aí que comecei a deixar a IA ler o Vault (o lugar onde as notas ficam) e assumir mais ou menos metade da organização. Colar link, fazer resumo, recolher a nota perdida. Rodando isso um pouquinho todo dia, as notas que estavam soltas começaram a se conectar sozinhas e ficaram, de verdade, com cara de “segundo cérebro”. Hoje vou contar essa história.

Afinal, o que é “a nota crescer”?

Uma nota comum tem o pico no instante em que você a escreve. Depois disso, ela só vai sendo esquecida.

Mas o Obsidian tem um jeito de escrever, [[nome da nota]], que liga uma nota à outra (chamamos de Wikilink), e quanto mais você liga, mais aquilo vira um mapa só. Da nota de “erro de tipo no TypeScript” você salta pra “aquele dia em que empaquei no Docker”, e dali conecta com “a retrospectiva do incidente do mês passado”. É a sensação de ponto virar linha, e linha virar área.

O problema é que fazer essa ligação na mão é chato demais e você não mantém.

Aqui é onde entra a IA. Mais especificamente, como parceiro, a gente usa uma ferramenta chamada Claude Code. É uma IA pra escrever código, mas na real dá pra usar como “o assistente que lê e escreve com segurança uma pasta cheia de Markdown”. O bom do local-first do Obsidian (os arquivos ficam no seu PC) continua igual, e você só passa pra IA o trabalho chato de organizar. Esse é o plano de hoje.

Só que deixa eu cravar uma coisa logo de cara. Dar à IA permissão de edição sobre o Vault inteiro é algo que você deve evitar a todo custo.

A .obsidian/ (a pasta de configuração), os artigos já publicados, as notas pessoais tipo contrato, as chaves de API — não há motivo pra deixar a IA ler nada disso. Por isso eu trabalho com a política de “leitura larga, escrita super cautelosa”. É a mesma ideia daquele que escrevi antes, como montar o “andaime” pra delegar trabalho à IA: no fundo, é pôr as rodinhas antes de sair pedalando.

Onde isso faz diferença (3 casos)

Na teoria não passa a mensagem, então três momentos em que eu de fato senti “opa, isso funciona”.

O primeiro é o log diário da manhã. Toda manhã, mando a IA ler a nota do dia anterior e peço “passa pra hoje só as tarefas que não terminaram e comprime o aprendizado de ontem em 3 linhas”. Aí a bagunça que o eu de ontem deixou sai arrumada num formato em que o eu de hoje consegue agir. “Ah, é aquilo em que eu tinha empacado ontem” — você lembra num instante. A pessoa pra quem você passa o bastão é o seu eu do futuro.

O segundo é o resgate de fragmento de código. Aquele problema do “comando de dois anos atrás”. Se você joga os comandos que funcionaram dentro da pasta snippets/, a IA acrescenta sozinha um texto de “pra que serve este comando?” e os links pras outras notas relacionadas. O comando pelado vira uma “nota de respeito” que aparece na busca.

O terceiro é o preparo da pauta de artigo. No dia de escrever no blog, mostro à IA o caderninho de ideias da pasta content-ops/ e pergunto “este artigo dá pra fazer link interno com qual artigo antigo?”. Tem vez que ela puxa um artigo de seis meses atrás que eu mesmo tinha esquecido, e isso ajuda de mansinho. É aquele instante em que ponto e ponto se conectam.

3 vacilos que eu mesmo cometi

Talvez a partir daqui seja o âmago. Nas primeiras semanas, meu Vault foi devastado pela IA. Vou expor com honestidade.

Primeiro. De cara, pedi “organiza tudo” pro Vault inteiro. Esse foi o pior. A IA tentou “gentilmente” organizar até as notas sem sentido de dois anos atrás e brotou um monte de tag e título por conta própria. O Graph view (a tela que visualiza as ligações entre notas) virou uma selva cheia de tags que eu não conhecia. A intenção da nota antiga, a IA não tem como saber. Mas ela age por palpite. Desde então, o alvo é sempre só uma pasta.

Segundo. Deixei a IA mudar o nome das notas por conta própria. “Deixa o título mais claro pra mim.” Com isso, os links [[nome antigo da nota]] quebraram todos de uma vez. O Obsidian, se você mesmo muda o nome, faz o link acompanhar; mas quando uma IA externa reescreve o nome do arquivo em lote, esse acompanhamento não funciona. Um cemitério de links quebrados. Hoje, “renomear sempre confere com o humano” é lei de ferro.

Terceiro. Deixei a IA ler a private/. Esse não foi só um susto. A pasta com as notas dos valores de contrato estava num estado em que a IA podia ler, porque eu fui preguiçoso na configuração de permissão. Não houve acidente, mas foi como deixar um estagiário tocar o banco de produção com a mão nua. Se eu tivesse escrito direito no deny (lista de proibição), não tinha nem como dar acidente. A lição é: a culpa foi minha, por economizar na configuração.

Como começar: ponha só 3 arquivos

Não é difícil. Na raiz do Vault, é só preparar três.

Primeiro, separe as pastas. Classificar fininho demais desde o começo quebra sem falta, então no atacado já basta.

# Execute na raiz do Vault. Separe só local de uso diário, projetos, trabalho público e área protegida
mkdir -p inbox daily projects content-ops snippets templates scripts archive private

O papel de cada pasta e até onde delegar à IA, eu divido assim.

Pasta	Papel	Alcance que delego à IA
inbox/	Recipiente de notas soltas e clips da Web	Leitura e criação nova
daily/	Log diário, nota de trabalho	Criar, acrescentar, resumir o dia anterior
projects/	Tarefas em andamento, passagem de bastão	Criar, atualizar, organizar pendências
content-ops/	Ideias de artigo, link interno, checagem de publicação	Organizar rascunho, conferir link
snippets/	Fragmento de código e seu uso	Acrescentar explicação, organizar tag
templates/	Templates do Obsidian	Por princípio, só editar após confirmar
archive/	Concluído, arquivado	Edição proibida
private/	Dado pessoal, contrato, segredo	Leitura também proibida

Depois, ponha um CLAUDE.md na raiz do Vault. É o papel onde estão escritas “as nossas regras” pra IA. Em vez de filosofar uma ideologia longa, escrever curto as regras de entrada e saída que você quer que ela respeite funciona melhor.

# Regras do Vault do Obsidian

## Papel
- Este Vault é o lugar de log diário, passagem de bastão de projeto, fragmento de código e ideia de artigo.
- Trabalhar de forma a ser útil sem precisar ler private.

## Política das pastas
- `daily/`: criar e atualizar nota diária no formato `YYYY-MM-DD.md`.
- `projects/`: manter uma nota de passagem de bastão por projeto ativo.
- `snippets/`: deixar o comando que funciona junto com o contexto e o exemplo de falha.
- `templates/`: ler à vontade. Antes de editar, sempre perguntar.
- `archive/` e `private/`: não editar. O conteúdo de private nem resumir.

## Regras de escrita
- Escrever link interno no formato Wikilink `[[nome do projeto]]`.
- Pôr propriedades YAML (status etc.) no topo da nota.
- Manter cada parágrafo em até 5 linhas.

## Regras de segurança
- Renomear nota existente: sempre confirmar antes.
- Não reescrever a configuração de `.obsidian/`.
- Antes de uma edição em lote, listar os arquivos-alvo e esperar a aprovação.
- Depois de editar, rodar sempre `node scripts/audit-wikilinks.cjs .`.

O último é o mais importante. Em .claude/settings.json, você amarra a permissão de forma física. O CLAUDE.md é um “pedido”; este aqui é uma “trava física”. É o porteiro pra nunca mais repetir o terceiro vacilo. Leitura larga, escrita só na pasta de trabalho, operação perigosa fechada por completo no deny. Os detalhes da configuração, veja a documentação oficial de permissões.

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Read(./CLAUDE.md)",
      "Read(./daily/**)",
      "Read(./projects/**)",
      "Read(./content-ops/**)",
      "Read(./snippets/**)",
      "Read(./templates/**)",
      "Read(./scripts/**)",
      "Edit(./daily/**)",
      "Edit(./projects/**)",
      "Edit(./content-ops/**)",
      "Edit(./snippets/**)",
      "Write(./inbox/**)",
      "Write(./daily/**)",
      "Write(./projects/**)",
      "Write(./content-ops/**)",
      "Write(./snippets/**)",
      "Bash(node scripts/audit-wikilinks.cjs .)"
    ],
    "ask": [
      "Edit(./templates/**)",
      "Bash(git *)"
    ],
    "deny": [
      "Read(./private/**)",
      "Read(./**/.env)",
      "Read(./**/.env.*)",
      "Edit(./.obsidian/**)",
      "Edit(./archive/**)",
      "Write(./archive/**)",
      "Bash(rm *)",
      "Bash(del *)"
    ]
  }
}

Com esses três papéis no lugar, depois é só pedir. O truque é não dizer “organiza aí, do jeito que ficar bom”. Alcance, entregável, proibições e até a verificação: especifique tudo, toda vez.

Leia daily/2026-06-04.md e projects/site-refresh.md.
Com base em templates/daily.md, crie daily/2026-06-05.md.
Das tarefas que não terminaram, passe adiante só as que ainda são minhas.
Não toque em .obsidian/, archive/ e private/.
Quando terminar de editar, rode node scripts/audit-wikilinks.cjs . e relate o resultado.

É curto, mas entrada, saída, alcance proibido e comando de verificação estão todos ali. Tem uma reprodutibilidade muitas vezes maior que a do “do jeito que ficar bom”.

O porteiro do acabamento: checar link quebrado pela máquina

Quando você deixa uma IA externa editar arquivos, de vez em quando o Wikilink quebra. No olho humano, escapa. Por isso, no fim, encaixe um script que cata de forma mecânica os links quebrados. Salve isto como scripts/audit-wikilinks.cjs.

#!/usr/bin/env node
// Script porteiro que cata links internos ([[...]]) quebrados ou ambíguos dentro do Vault
const fs = require("node:fs");
const path = require("node:path");

const vaultRoot = path.resolve(process.argv[2] || ".");
const ignoredDirs = new Set([".git", ".obsidian", ".trash", "node_modules"]);
const allFiles = [];
const markdownFiles = [];

function walk(dir) {
  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
    if (ignoredDirs.has(entry.name)) continue;
    const full = path.join(dir, entry.name);
    if (entry.isDirectory()) {
      walk(full);
    } else if (entry.isFile()) {
      allFiles.push(full);
      if (entry.name.toLowerCase().endsWith(".md")) markdownFiles.push(full);
    }
  }
}

function toPosix(filePath) {
  return filePath.split(path.sep).join("/");
}

function withoutMd(value) {
  return value.replace(/\.md$/i, "");
}

function stripTarget(raw) {
  return raw.split("|")[0].split("#")[0].split("^")[0].trim();
}

function safeDecode(value) {
  try {
    return decodeURIComponent(value);
  } catch {
    return value;
  }
}

function isExternal(target) {
  return /^(https?:|mailto:|obsidian:|#|\/)/i.test(target);
}

function candidateKeys(target, fromFile) {
  const clean = safeDecode(stripTarget(target));
  if (!clean) return [];
  const keys = new Set();
  const normalized = toPosix(path.normalize(clean));
  keys.add(normalized);
  keys.add(withoutMd(normalized));

  if (clean.includes("/") || clean.includes("\\")) {
    const fromDir = path.dirname(toPosix(path.relative(vaultRoot, fromFile)));
    const relative = toPosix(path.normalize(path.join(fromDir, clean)));
    keys.add(relative);
    keys.add(withoutMd(relative));
  } else {
    keys.add(withoutMd(path.posix.basename(normalized)));
    keys.add(path.posix.basename(normalized));
  }

  return [...keys].filter(Boolean);
}

walk(vaultRoot);

const byPath = new Map();
const byBase = new Map();

for (const file of allFiles) {
  const rel = toPosix(path.relative(vaultRoot, file));
  const lowerRel = rel.toLowerCase();
  byPath.set(lowerRel, file);
  if (rel.toLowerCase().endsWith(".md")) byPath.set(withoutMd(lowerRel), file);

  const base = rel.toLowerCase().endsWith(".md")
    ? withoutMd(path.posix.basename(rel)).toLowerCase()
    : path.posix.basename(rel).toLowerCase();
  const list = byBase.get(base) || [];
  list.push(file);
  byBase.set(base, list);
}

const problems = [];
const wikilink = /!?\[\[([^\]]+)\]\]/g;
const markdownLink = /!?\[[^\]]*\]\(([^)]+)\)/g;

for (const file of markdownFiles) {
  const text = fs.readFileSync(file, "utf8");
  const rel = toPosix(path.relative(vaultRoot, file));
  const targets = [];
  let match;

  while ((match = wikilink.exec(text))) targets.push(match[1]);
  while ((match = markdownLink.exec(text))) {
    const target = match[1].replace(/^<|>$/g, "").trim();
    if (!isExternal(target)) targets.push(target);
  }

  for (const target of targets) {
    const clean = stripTarget(target);
    if (!clean || isExternal(clean)) continue;
    const keys = candidateKeys(clean, file);
    const pathHit = keys.some((key) => byPath.has(key.toLowerCase()));
    const baseHits = keys.flatMap((key) => byBase.get(path.posix.basename(key).toLowerCase()) || []);

    if (!pathHit && baseHits.length === 0) {
      problems.push(`${rel} -> missing [[${clean}]]`);
    } else if (!pathHit && baseHits.length > 1) {
      problems.push(`${rel} -> ambiguous [[${clean}]] (${baseHits.length} matches)`);
    }
  }
}

if (problems.length) {
  console.error("Foram encontrados links internos quebrados/ambíguos:");
  for (const problem of problems) console.error(`- ${problem}`);
  process.exit(1);
}

console.log(`OK: verifiquei ${markdownFiles.length} arquivos Markdown em ${vaultRoot}`);

Pra rodar, é só isto.

node scripts/audit-wikilinks.cjs .

Se todos os links estiverem vivos, sai OK. Se algum estiver quebrado, ele te diz numa lista qual link de qual arquivo está morto. Rodar isso logo depois de a IA organizar é o meu encerramento de todo dia.

A propósito, a especificação exata do lado do Obsidian (Daily notes, Templates, Properties, link interno), consulte na ajuda oficial do Obsidian. Antes de delegar à IA, entender você mesmo a especificação da nave-mãe evita que você dê uma instrução estranha.

O que aconteceu quando testei na prática

Por 3 meses, rodei o meu Vault com esse mecanismo.

O que mais funcionou foi, mesmo, a “passagem de bastão do log diário” e a “auditoria de links antes de publicar”. De manhã cedo, quando mando a IA resumir o dia anterior, o motor pega num ritmo claramente mais rápido. Como “o eu de ontem tinha parado aqui” fica visível num relance, enquanto eu passo o café a cabeça já troca pro modo de hoje. Depois que passei a encaixar a auditoria de links, sumiram as noites em que eu publicava um artigo e empalidecia com “opa, o link interno quebrou”. Em número: antes da auditoria, eu publicava link quebrado 2 a 3 vezes por mês; hoje é zero.

E teve outro subproduto inesperado. Por ter assumido a premissa de deixar a IA tocar tudo todo dia, o meu próprio jeito de escrever nota mudou. Pensando que depois a máquina vai ler, eu naturalmente passei a pôr status: ou a acrescentar uma linha de contexto até numa nota porca. Eu achava que estava arrumando pra IA, mas quem ficou mais fácil de ler, no fim, foi o humano que eu sou.

Em compensação, a vez em que organizei o Vault inteiro de uma vez logo no começo foi um fracasso nítido. A IA chutou demais o sentido das notas antigas, e tag e título, em vez de cair, aumentaram e bagunçaram. A conclusão é simples: quanto mais você respeita os 3 pontos “alcance estreito, template fininho, auditoria Node no fim”, melhor sai.

O engraçado é que aquele comando de dois anos atrás, que meio ano antes eu jamais conseguiria lembrar, hoje eu alcanço em 5 segundos. Os links que a IA colou com afinco, eu só sigo. A nota, de fato, virou cérebro.

Resumo

A verdade do “a nota cresce sozinha” não é magia. Leitura larga, escrita estreita, e no fim a máquina confere a conta. Só transformei esse óbvio em mecanismo.

São 3 coisas a fazer. Separar as pastas, escrever as regras no CLAUDE.md e tapar de forma física a operação perigosa em .claude/settings.json. Depois, é só pedir sem dizer “do jeito que ficar bom”, estreitando o alcance. Hoje, comece só pela daily/. O seu eu de amanhã vai ficar um pouquinho mais aliviado.

Quem quiser conhecer com mais detalhe a forma de pensar permissão e sandbox, dá uma olhada também em o desenho de aprovação e sandbox do Claude Code. Os templates pra botar a mão na massa e o contato pra consultoria de adoção em equipe estão reunidos na lista de materiais.