Tus notas de Obsidian “crecen solas” con IA. Cómo montar un segundo cerebro

A las doce de la noche, yo estaba tecleando en el buscador de Obsidian “aquel comando, ¿cuál era?”.

Un comando de shell de tres líneas que apunté hace dos años. Que existe, seguro que existe. Pero en cuál de las más de 500 notas estaba enterrado, no había manera de recordarlo. Al final, aquel día me rendí de buscarlo y volví a googlearlo.

Esto no me pasa solo a mí, estoy seguro.

Obsidian (la app de notas) se vuelve más útil cuanto más la usas. Pero a la vez, se desordena sin remedio. Logs diarios, notas de lectura, fragmentos de código, ideas para artículos, actas de reunión. Todo se va acumulando como archivos Markdown y, en medio año, tienes “tu propia casa de la basura, imposible de buscar”.

Por eso empecé a hacer una cosa: dejar que la IA lea el Vault (el almacén de las notas) y me releve de la mitad del trabajo de ordenarlo. Que ponga enlaces, que haga resúmenes, que rescate las notas perdidas. Si esto lo voy haciendo un poquito cada día, las notas que estaban dispersas empiezan a conectarse solas y, de verdad, aquello empieza a parecerse a un “segundo cerebro”. Hoy te cuento eso.

Para empezar, ¿qué significa que “las notas crezcan”?

Una nota normal tiene su pico en el momento en que la escribes. A partir de ahí, solo se olvida.

Pero Obsidian tiene una forma de escribir, [[nombre de nota]], que conecta unas notas con otras (se llama Wikilink), y cuanto más conectas, más se va formando un mapa de una sola pieza. Desde la nota de “error de tipos en TypeScript” saltas a “aquel día que me atasqué con Docker”, y de ahí enlazas con “la retrospectiva de la incidencia del mes pasado”. Es esa sensación de que los puntos se vuelven líneas y las líneas, superficies.

El problema es que si ese enlazado lo hace un humano, es tan latoso que no hay quien lo mantenga.

Esto se lo dejamos a la IA. En concreto, uso como compañero la herramienta Claude Code. Es una IA pensada para escribir código, pero en el fondo se puede usar como “el encargado que lee y escribe con seguridad una carpeta repleta de archivos Markdown”. La bondad local-first de Obsidian (que los archivos viven en tu propio PC) se queda igual; solo le pasas a la IA la lata de ordenar. Ese es el plan de hoy.

Eso sí, deja que te clave una advertencia al principio. Darle a la IA permiso de edición sobre todo el Vault es algo que más vale no hacer jamás.

La carpeta .obsidian/ (la de configuración), los artículos ya publicados, notas personales tipo contratos, las claves de API: no hay razón para que la IA las lea. Por eso yo voy con la política de “lectura, amplia; escritura, ultra prudente”. Es exactamente la forma de pensar de lo que escribí en cómo montarle un andamio a la IA, y en el fondo es lo mismo: ponerle los ruedines antes de dejarla correr.

Dónde se nota de verdad (tres casos)

Como en abstracto no se transmite, van tres momentos en los que de verdad sentí “anda, esto sí funciona”.

El primero, el log diario de la mañana. Cada mañana le hago leer a la IA las notas del día anterior y le pido “pasa a hoy solo las tareas sin terminar, y comprime en 3 líneas lo que aprendí ayer”. Y entonces, las notas que el yo de ayer dejó desordenadas salen en una forma con la que el yo de hoy ya puede moverse. “Ah, esto es en lo que me atasqué ayer”, lo recuerdo al instante. La persona a la que le haces el traspaso es tu yo del futuro.

El segundo, el rescate de fragmentos de código. El problema del “comando de hace dos años” de antes. Si voy tirando en la carpeta snippets/ los comandos que me funcionaron, la IA les añade sola una explicación de “¿para qué sirve este comando?” y enlaces a otras notas relacionadas. El comando desnudo se transforma en una “nota como Dios manda” que sí aparece al buscar.

El tercero, preparar el terreno para ideas de artículos. El día que escribo en el blog, le enseño a la IA el cuaderno de ideas de la carpeta content-ops/ y le pregunto “este artículo, ¿a qué artículos antiguos podría enlazar por dentro?”. A veces me saca un artículo de hace medio año que yo mismo había olvidado, y eso se nota más de lo que parece. Es ese instante en que los puntos se conectan.

Tres metidas de pata que cometí yo

Igual esto es lo más jugoso. Las primeras semanas, la IA me destrozó el Vault. Lo confieso sin tapujos.

La primera. Le pedí de golpe “ordena” todo el Vault. Esta fue la peor. La IA intentó “amablemente” ordenar hasta las notas incomprensibles de hace dos años y me hizo brotar a mansalva etiquetas y títulos por su cuenta. La Graph view (la pantalla que visualiza las conexiones entre notas) se convirtió en una jungla llena de etiquetas que yo no conocía. La intención de una nota vieja, la IA no la puede saber. Y aun así, actúa por suposiciones. Desde aquello, el objetivo lo limito siempre a una sola carpeta.

La segunda. Dejé que la IA cambiara los nombres de las notas por su cuenta. “Pon títulos más claros.” Con esto, los enlaces [[nombre viejo de nota]] se rompieron todos a la vez. Si cambias tú mismo el nombre, Obsidian hace que los enlaces lo sigan; pero cuando una IA externa reescribe los nombres en bloque, ese seguimiento no funciona. Un cementerio de enlaces rotos. Ahora tengo como ley de hierro: “renombrar, siempre con confirmación humana”.

La tercera. Dejé que leyera private/. Esto fue más que un vuelco en el estómago. Por vaguear con la configuración de permisos, tenía la carpeta con la nota del importe de un contrato en un estado en que la IA podía leerla. No pasó nada, pero fue como dejar que un becario tocara la base de datos de producción a mano pelada. Si lo hubiera puesto bien en deny (la lista de denegación), el accidente ni habría sido posible. La lección: el culpable fui yo por escatimar en la configuración.

Cómo empezar: solo colocas tres archivos

No tiene misterio. Justo en la raíz del Vault, preparas tres cosas.

Primero, separas en carpetas. Si desde el principio clasificas demasiado fino, revientas seguro, así que con algo aproximado basta.

# Ejecútalo en la raíz del Vault. Separa solo lo de uso diario, los proyectos, el trabajo de publicación y la zona protegida
mkdir -p inbox daily projects content-ops snippets templates scripts archive private

El papel de cada carpeta y hasta dónde le dejo a la IA, lo tengo repartido así.

Carpeta	Papel	Alcance que delego a la IA
inbox/	Notas sin ordenar, recortes web	Lectura y creación nueva
daily/	Logs diarios, notas de trabajo	Crear, añadir, resumir el día anterior
projects/	Tareas en curso, traspasos	Crear, actualizar, ordenar lo pendiente
content-ops/	Ideas de artículos, enlaces internos, revisión de publicación	Ordenar borradores, comprobar enlaces
snippets/	Fragmentos de código y su uso	Añadir explicaciones, ordenar etiquetas
templates/	Plantillas de Obsidian	En principio, editar solo tras confirmar
archive/	Terminado, archivado	Edición prohibida
private/	Datos personales, contratos, secretos	Lectura también prohibida

Después, en la raíz del Vault colocas un CLAUDE.md. Es el papel donde escribes “las reglas de la casa” para la IA. Más que soltar una filosofía larga, funciona mejor escribir corto las reglas de entrada y salida que quieres que respete.

# Reglas del Vault de Obsidian

## Papel
- Este Vault es el sitio para logs diarios, traspasos de proyecto, fragmentos de código e ideas de artículos.
- Debe funcionar de forma útil sin necesidad de leer private.

## Política de carpetas
- `daily/`: crea y actualiza notas diarias con el formato `YYYY-MM-DD.md`.
- `projects/`: mantén una nota de traspaso por cada proyecto activo.
- `snippets/`: deja juntos el comando que funciona y su contexto y ejemplos de fallo.
- `templates/`: leer, libre. Antes de editar, pregunta siempre.
- `archive/` y `private/`: no editar. De private, no resumir ni su contenido.

## Reglas de escritura
- Los enlaces internos, en formato Wikilink `[[nombre de proyecto]]`.
- Pon propiedades YAML (status, etc.) al principio de la nota.
- Cada párrafo, dentro de 5 líneas.

## Reglas de seguridad
- Renombrar notas existentes, confirma siempre antes.
- No reescribas la configuración de `.obsidian/`.
- Antes de una edición en bloque, saca la lista de archivos objetivo y espera aprobación.
- Tras editar, ejecuta siempre `node scripts/audit-wikilinks.cjs .`.

Lo último es lo más importante. Con .claude/settings.json atas los permisos físicamente. El CLAUDE.md es una “petición”; esto es un “candado físico”. Es el guardián para no repetir nunca más la tercera de mis cagadas. Lectura, amplia; escritura, solo en las carpetas de trabajo; las operaciones peligrosas, cerradas a cal y canto con deny. Los detalles de la configuración míralos en la documentación oficial de permisos.

{
  "$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 *)"
    ]
  }
}

Una vez colocadas estas tres hojas, ya solo queda pedir. El truco es no decir “ordénalo bonito”. El alcance, el entregable, las prohibiciones y hasta la verificación: lo indicas todo cada vez.

Lee daily/2026-06-04.md y projects/site-refresh.md.
A partir de templates/daily.md, crea daily/2026-06-05.md.
Las tareas sin terminar, traspasa solo las que sigan siendo del mismo responsable.
No toques .obsidian/, archive/ ni private/.
Cuando termines de editar, ejecuta node scripts/audit-wikilinks.cjs . y reporta el resultado.

Es corto, pero lleva todo: entrada, salida, alcance prohibido y comando de verificación. Mucho más reproducible que un “ordénalo bonito”.

El guardián del remate: comprobar enlaces rotos con una máquina

Cuando dejas que una IA externa edite archivos, de vez en cuando rompe algún Wikilink. A ojo, se te escapa. Por eso, al final, meto un script que rastrea de forma mecánica los enlaces rotos. Guárdalo como scripts/audit-wikilinks.cjs.

#!/usr/bin/env node
// Script guardián que rastrea enlaces internos ([[...]]) rotos o ambiguos dentro del 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("Se encontraron enlaces internos rotos o ambiguos:");
  for (const problem of problems) console.error(`- ${problem}`);
  process.exit(1);
}

console.log(`OK: se revisaron ${markdownFiles.length} archivos Markdown en ${vaultRoot}`);

Y para ejecutarlo, solo esto.

node scripts/audit-wikilinks.cjs .

Si todos los enlaces están vivos, sale OK. Si hay alguno roto, te dice en una lista qué enlace de qué archivo está muerto. Lanzar esto justo después de que la IA ordene es mi cierre de cada día.

Por cierto, las especificaciones exactas de los mecanismos del lado de Obsidian (Daily notes, Templates, Properties, enlaces internos) consúltalas en la ayuda oficial de Obsidian. Si entiendes tú las especificaciones de la nave nodriza antes de delegar en la IA, te ahorras darle instrucciones raras.

Lo que pasó cuando lo probé de verdad

Llevo 3 meses moviendo mi Vault con este sistema.

Lo que más sirvió fue, como era de esperar, el “traspaso del log diario” y la “auditoría de enlaces antes de publicar”. Cuando a primera hora hago que la IA resuma el día anterior, el motor arranca claramente más rápido. “Ah, el yo de ayer se quedó parado aquí”, lo veo de un vistazo, y mientras me preparo el café la cabeza se me pone ya en modo de hoy. Desde que metí la auditoría de enlaces, las noches de ponerme pálido pensando “ay, dejé un enlace interno roto” tras publicar un artículo son cero. En números: antes de la auditoría publicaba enlaces rotos 2 o 3 veces al mes; ahora, cero.

Y hubo otro efecto secundario inesperado. El hecho de tener asumido que la IA va a tocar mis notas a diario cambió mi propia forma de escribirlas. Como sé que luego las leerá una máquina, sin querer empiezo a ponerles un status:, o a añadir una sola línea de contexto incluso a una nota descuidada. Creía que estaba ordenando para la IA, pero al final quien más cómodo leía era el yo humano.

En cambio, la vez que dejé que ordenara de golpe todo el Vault al principio fue un fracaso claro. La IA suponía demasiado el sentido de las notas viejas, y las etiquetas y los títulos más bien aumentaron y se desordenó. La conclusión es simple: cuanto más respetas los tres puntos —alcance estrecho, plantillas finas y auditoría con Node al final—, mejor sale.

Lo curioso es que a aquel comando de hace dos años, que hace medio año no habría recordado ni de coña, hoy llego en 5 segundos. Solo sigo los enlaces que la IA fue pegando con paciencia. Las notas se han ido volviendo, de verdad, un cerebro.

En resumen

La verdadera identidad de “las notas crecen solas” no es magia. Lectura amplia, escritura estrecha, y al final una máquina que repasa los números. Es solo haber convertido en sistema esta obviedad.

Lo que hay que hacer son tres cosas. Separa en carpetas, escribe las reglas en CLAUDE.md y tapa físicamente las operaciones peligrosas con .claude/settings.json. El resto es no decir “bonito” y pedir con el alcance bien acotado. Empieza hoy por una sola carpeta, daily/. El yo de mañana lo tendrá un poco más fácil.

Si quieres conocer con más detalle la forma de pensar los permisos y el sandbox, pásate también por diseño de aprobación y sandbox de Claude Code. Plantillas para mover las manos y dónde consultar la implantación en equipo, los tienes recogidos en el listado de materiales.