Deine Obsidian-Notizen „wachsen von selbst“ mit KI. So baust du dir ein zweites Gehirn

Nachts um null Uhr tippte ich ins Suchfeld von Obsidian: „Wie hieß dieser Befehl noch mal?“

Ein Shell-Befehl von drei Zeilen, notiert vor zwei Jahren. Dass es ihn gibt, ist sicher. Aber wo unter den über 500 Notizen er vergraben liegt, fiel mir partout nicht mehr ein. Am Ende gab ich die Suche an jenem Tag auf und googelte ihn noch einmal.

Das geht, glaube ich, nicht nur mir so.

Obsidian (eine Notiz-App) wird mit jeder Nutzung praktischer. Aber zugleich verstreut es zuverlässig. Tageslogs, Lesenotizen, Code-Fetzen, Artikelideen, Besprechungsnotizen. Alles sammelt sich als Markdown-Datei an, und nach einem halben Jahr hast du eine „schwer durchsuchbare Messie-Bude nur für dich“.

Da fing ich an: Ich lasse die KI den Vault (den Notizspeicher) lesen und die Hälfte des Aufräumens übernehmen. Links setzen, Zusammenfassungen bauen, verirrte Notizen aufsammeln. Drehe ich das täglich ein bisschen, fangen die zuvor verstreuten Notizen von selbst an, sich zu verbinden, und es wird tatsächlich „zweites Gehirn“-mäßig. Davon erzähle ich heute.

Was heißt überhaupt „Notizen wachsen“?

Bei einer normalen Notiz ist der Moment des Schreibens der Höhepunkt. Danach wird sie nur noch vergessen.

Aber Obsidian hat mit der Schreibweise [[Notizname]] eine Funktion, die Notizen verknüpft (man nennt sie Wikilink), und je mehr man verknüpft, desto mehr wird daraus eine zusammenhängende Landkarte. Von der Notiz „TypeScript-Typfehler“ springst du zu „die Docker-Sache, an der ich an dem Tag hing“, und von dort weiter zu „der Rückblick auf den Vorfall letzten Monat“. Punkte werden zu Linien, Linien zu Flächen.

Das Problem: Macht ein Mensch dieses Verknüpfen, ist es zu lästig, um durchzuhalten.

Das übergibst du der KI. Konkret nutze ich als Kumpel das Werkzeug Claude Code. Das ist eine KI zum Code-Schreiben, taugt aber im Kern als „Arbeiter, der einen Ordner voller Markdown-Dateien sicher lesen und schreiben kann“. Obsidians Local-First-Stärke (die Dateien liegen auf deinem eigenen PC) bleibt, nur die Mühe des Aufräumens gibst du der KI. Das ist der heutige Plan.

Nur einen Pfahl schlage ich vorab ein. Der KI Schreibrechte für den ganzen Vault zu geben, solltest du auf gar keinen Fall.

.obsidian/ (der Einstellungsordner), bereits veröffentlichte Artikel, vertragsähnliche persönliche Notizen, API-Schlüssel – es gibt keinen Grund, der KI das zu zeigen. Deshalb fahre ich nach der Devise „Lesen großzügig, Schreiben extrem vorsichtig“. Das ist genau die Denkweise aus meinem früheren Beitrag Wie man der KI ein Gerüst baut – im Kern: erst die Stützräder dran, dann losfahren.

In diesen Situationen zahlt es sich aus (drei)

Abstrakt kommt es nicht rüber, also drei Momente, in denen ich tatsächlich „oh, das wirkt“ gespürt habe.

Erstens: das morgendliche Tageslog. Jeden Morgen lasse ich die KI die Notiz vom Vortag lesen und bitte: „Übertrag nur die unerledigten Aufgaben auf heute und press die Erkenntnisse von gestern in drei Zeilen.“ Dann kommt das Geschmiere, das mein gestriges Ich hinterlassen hat, in einer Form heraus, in der mein heutiges Ich loslegen kann. „Ach ja, daran hing ich gestern“ – in einer Sekunde wieder präsent. Der Übergabepartner ist das zukünftige Ich.

Zweitens: die Rettung von Code-Fetzen. Das „Befehl von vor zwei Jahren“-Problem von eben. Wirfst du funktionierende Befehle in den Ordner snippets/, ergänzt die KI von selbst einen Erklärsatz „Wofür ist dieser Befehl?“ und Links zu verwandten Notizen. Aus dem nackten Befehl wird eine „ordentliche Notiz“, die man per Suche findet.

Drittens: die Vorbereitung von Artikelideen. Am Schreibtag zeige ich der KI das Ideenheft im Ordner content-ops/ und frage: „Auf welchen alten Artikel könnte dieser hier intern verlinken?“ Manchmal zieht sie einen Artikel von vor einem halben Jahr hervor, den ich selbst vergessen hatte – das wirkt unscheinbar gut. Genau dieser Moment, wenn sich Punkt und Punkt verbinden.

Drei Fehler, die ich selbst gebaut habe

Vielleicht ist das hier der eigentliche Kern. In den ersten Wochen wurde mein Vault von der KI nach Strich und Faden verwüstet. Ich leg es ehrlich offen.

Der erste. Ich bat gleich, „den ganzen Vault aufzuräumen“. Das war am schlimmsten. Die KI versuchte, sogar die unverständlichen Notizen von vor zwei Jahren „freundlicherweise“ aufzuräumen, und ließ massenhaft eigenmächtige Tags und Überschriften sprießen. Die Graph view (das Bild, das die Verbindungen der Notizen sichtbar macht) wurde zum Dschungel voller unbekannter Tags. Die Absicht alter Notizen kann die KI nicht kennen. Trotzdem handelt sie auf Verdacht. Seither begrenze ich das Ziel immer auf genau einen Ordner.

Der zweite. Ich ließ die KI Notiznamen eigenmächtig ändern. „Mach die Titel mal verständlicher.“ Damit rissen auf einen Schlag die Links [[alter Notizname]]. Benennst du selbst um, folgt Obsidian auch den Links nach, aber wenn eine externe KI die Dateinamen im Block umschreibt, greift dieses Nachziehen nicht. Tote Links, Leichenberge. Heute ist „Umbenennen immer beim Menschen rückfragen“ eiserne Regel.

Der dritte. Ich ließ private/ lesen. Das war mehr als nur ein Schreckmoment. Den Ordner mit der Notiz über Vertragssummen hatte ich, weil ich mir die Rechte-Einstellung gespart hatte, für die KI lesbar gelassen. Ein Unfall passierte nicht, aber das war, als hätte ich einen Neuling mit bloßer Hand an die Produktions-DB gelassen. Steht es ordentlich in der deny-Liste, kann gar nichts passieren. Selbst schuld, dass ich an der Einstellung gespart habe – das war die Lehre.

Der Einstieg: nur drei Dateien hinlegen

Nicht schwierig. Du legst direkt unter dem Vault nur drei Dinge an.

Zuerst teilst du die Ordner auf. Klassifizierst du von Anfang an zu fein, bricht es garantiert zusammen, also reicht grob.

# Direkt unter dem Vault ausführen. Nur trennen: Alltag, Projekte, Veröffentlichung, Schutzzone
mkdir -p inbox daily projects content-ops snippets templates scripts archive private

Die Rolle jedes Ordners und wie weit ich der KI vertraue, teile ich so auf.

Ordner	Rolle	Was die KI darf
inbox/	Auffangbecken für unsortierte Notizen, Web-Clips	Lesen und neu anlegen
daily/	Tageslogs, Arbeitsnotizen	Anlegen, ergänzen, Vortag zusammenfassen
projects/	laufende Aufgaben, Übergaben	Anlegen, aktualisieren, offene Punkte ordnen
content-ops/	Artikelideen, interne Links, Veröffentlichungs-Check	Entwürfe ordnen, Links prüfen
snippets/	Code-Fetzen und ihre Nutzung	Erklärung ergänzen, Tags ordnen
templates/	Obsidian-Templates	Grundsatz: erst nach Rückfrage bearbeiten
archive/	erledigt, abgelegt	Bearbeiten verboten
private/	Persönliches, Verträge, Geheimes	auch Lesen verboten

Als Nächstes legst du direkt unter dem Vault eine CLAUDE.md an. Das ist das Blatt, auf dem „unsere Regeln“ für die KI stehen. Statt langer Philosophie wirkt es besser, die Ein- und Ausgaberegeln, die sie einhalten soll, kurz aufzuschreiben.

# Regeln des Obsidian-Vault

## Rolle
- Dieser Vault ist der Ort für Tageslogs, Projektübergaben, Code-Fetzen und Artikelideen.
- Arbeite so, dass du nützlich bist, ohne private lesen zu müssen.

## Ordner-Politik
- `daily/`: Tagesnotizen als `YYYY-MM-DD.md` anlegen und aktualisieren.
- `projects/`: pro aktivem Vorgang eine Übergabenotiz pflegen.
- `snippets/`: funktionierende Befehle zusammen mit Hintergrund und Fehlerbeispiel hinterlassen.
- `templates/`: Lesen frei. Vor dem Bearbeiten immer fragen.
- `archive/` und `private/`: nicht bearbeiten. Den Inhalt von private auch nicht zusammenfassen.

## Schreibregeln
- Interne Links im Wikilink-Format `[[Projektname]]` schreiben.
- Am Notizanfang YAML-Eigenschaften (status usw.) setzen.
- Ein Absatz bleibt unter fünf Zeilen.

## Sicherheitsregeln
- Bestehende Notizen umbenennen: immer vorher fragen.
- Die Einstellungen in `.obsidian/` nicht umschreiben.
- Vor einer Sammelbearbeitung die Zieldateien auflisten und auf Freigabe warten.
- Nach dem Bearbeiten immer `node scripts/audit-wikilinks.cjs .` laufen lassen.

Das Letzte ist das Wichtigste. Mit .claude/settings.json zurrst du die Rechte physisch fest. CLAUDE.md ist eine „Bitte“, das hier ist eine „physische Sperre“. Der Türsteher, damit sich Fehler Nummer drei nie wiederholt. Lesen großzügig, Schreiben nur im Arbeitsordner, gefährliche Operationen per deny komplett dicht. Details zur Einstellung siehst du in der offiziellen Rechte-Dokumentation.

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

Hast du diese drei Blätter hingelegt, bleibt nur noch das Bitten. Der Trick: sag nicht „Räum mal schön auf“. Bereich, Ergebnis, Verbote und sogar die Prüfung – gib jedes Mal alles an.

Lies daily/2026-06-04.md und projects/site-refresh.md.
Erstelle auf Basis von templates/daily.md die Datei daily/2026-06-05.md.
Übertrag von den unerledigten Aufgaben nur die, deren Zuständiger noch ich bin.
.obsidian/, archive/ und private/ nicht anfassen.
Wenn das Bearbeiten fertig ist, führ node scripts/audit-wikilinks.cjs . aus und berichte das Ergebnis.

Kurz, aber Eingabe, Ausgabe, Verbotsbereich und Prüfkommando sind alle drin. Um ein Vielfaches reproduzierbarer als „mach mal schön“.

Der finale Türsteher: tote Links maschinell prüfen

Lässt eine externe KI Dateien bearbeiten, brechen manchmal Wikilinks. Das menschliche Auge übersieht es. Deshalb klemmst du am Ende ein Skript dazwischen, das kaputte Links maschinell aufspürt. Speichere es als scripts/audit-wikilinks.cjs.

#!/usr/bin/env node
// Türsteher-Skript: spürt kaputte/mehrdeutige interne Links ([[...]]) im Vault auf
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("Kaputte/mehrdeutige interne Links gefunden:");
  for (const problem of problems) console.error(`- ${problem}`);
  process.exit(1);
}

console.log(`OK: ${markdownFiles.length} Markdown-Dateien in ${vaultRoot} geprüft`);

Ausgeführt wird so.

node scripts/audit-wikilinks.cjs .

Leben alle Links, erscheint OK. Ist etwas kaputt, sagt es dir in einer Liste, in welcher Datei welcher Link tot ist. Dieses Skript direkt nach dem Aufräumen durch die KI laufen zu lassen, ist mein täglicher Abschluss.

Übrigens: Die genauen Spezifikationen der Obsidian-Mechanik (Daily notes, Templates, Properties, interne Links) schlägst du in der offiziellen Obsidian-Hilfe nach. Verstehst du die Spezifikation deines Mutterschiffs, bevor du es der KI überlässt, gibst du keine komischen Anweisungen.

Was beim Ausprobieren herauskam

Drei Monate habe ich meinen Vault mit diesem System gedreht.

Am meisten gewirkt haben tatsächlich „die Übergabe per Tageslog“ und „das Link-Audit vor der Veröffentlichung“. Lasse ich die KI gleich morgens den Vortag zusammenfassen, springt der Motor sichtbar schneller an. „Hier bin ich gestern stehen geblieben“ sehe ich auf einen Blick, also schaltet sich der Kopf, während der Kaffee durchläuft, in den heutigen Modus. Seit ich das Link-Audit dazwischenklemme, gibt es null Nächte mehr, in denen ich nach einer Veröffentlichung erbleiche, weil „ein interner Link tot war“. In Zahlen: Vor dem Audit veröffentlichte ich zwei- bis dreimal im Monat einen toten Link, heute null.

Und ein unerwartetes Nebenprodukt. Dadurch, dass die Voraussetzung „die KI fasst das täglich an“ entstand, änderte sich meine eigene Art, Notizen zu schreiben. Im Wissen, dass eine Maschine es später liest, setze ich ganz natürlich status: oder füge selbst der schlampigsten Notiz eine Zeile Kontext hinzu. Gemeint hatte ich, ich richte es für die KI her – am lesbarsten wurde am Ende es für mich selbst als Mensch.

Umgekehrt war das Mal, an dem ich anfangs den ganzen Vault auf einen Schlag aufräumen ließ, ein klarer Fehlschlag. Die KI riet zu viel über den Sinn alter Notizen, und Tags und Überschriften wurden eher mehr und unordentlicher. Das Fazit ist simpel: Je strenger du „erlaubter Bereich eng, Templates dünn, am Ende Node-Audit“ einhältst, desto besser läuft es.

Das Spannende: An den Befehl von vor zwei Jahren, an den ich mich vor einem halben Jahr garantiert nicht mehr erinnert hätte, komme ich heute in fünf Sekunden. Ich folge nur den Links, die die KI fleißig gesetzt hat. Die Notizen sind wirklich zu einem Gehirn geworden.

Fazit

Das wahre Wesen von „Notizen wachsen von selbst“ ist keine Magie. Lesen großzügig, Schreiben eng, am Ende maschinell gegenrechnen. Ich habe nur diese Selbstverständlichkeit in ein System gegossen.

Zu tun sind drei Dinge. Die Ordner aufteilen, in CLAUDE.md die Regeln schreiben, mit .claude/settings.json die gefährlichen Operationen physisch dichtmachen. Den Rest: nicht „mach mal schön“ sagen, sondern den Bereich eng eingrenzen und bitten. Fang heute erst mal mit einem einzigen daily/ an. Dein morgiges Ich hat es ein bisschen leichter.

Wer die Denkweise zu Rechten und Sandbox genauer kennen will, schaut auch in Approval- und Sandbox-Design bei Claude Code. Vorlagen zum Selbermachen und Ansprechpartner für die Team-Einführung sind in der Materialübersicht gesammelt.