Obsidian के नोट AI से "अपने-आप पनपते" हैं। दूसरा दिमाग़ बनाने का इंतज़ाम

रात के बारह बजे, मैं Obsidian के सर्च बॉक्स में टाइप कर रहा था—“वो कमांड, क्या थी?”

दो साल पहले लिखी, बस तीन लाइन की एक शेल कमांड। है पक्का, यह मुझे यक़ीन था। पर पाँच सौ से ज़्यादा नोट में से किसमें दबी पड़ी है, कुछ याद ही नहीं आ रहा था। आख़िर उस दिन ढूँढना छोड़कर, मैंने फिर से गूगल कर लिया।

यह सिर्फ़ मेरे साथ नहीं होता, मुझे लगता है।

Obsidian (नोट ऐप) जितना इस्तेमाल करो, उतना काम का होता जाता है। पर साथ-साथ, पक्के तौर पर बिखरता भी जाता है। रोज़ की लॉग, पढ़ने की नोट, कोड के टुकड़े, लेख के विषय, मीटिंग की नोट। सब Markdown फ़ाइल बनकर जमते जाते हैं, और छह महीने में ही “अपने लिए बना, पर ढूँढने में मुश्किल कबाड़घर” बन जाता है।

तो मैंने जो शुरू किया, वह यह—Vault (नोट रखने की जगह) AI से पढ़वाकर, छँटाई का आधा बोझ उसके कंधे पर डाल देना। लिंक जोड़ना, सार बनाना, खोई हुई नोट उठा लाना। यह रोज़ थोड़ा-थोड़ा चलाते जाओ, तो बिखरे नोट अपने-आप जुड़ने लगते हैं, और वाक़ई “दूसरा दिमाग़” जैसा लगने लगता है। आज वही किस्सा।

आख़िर “नोट का पनपना” है क्या?

आम नोट की चोटी, लिखने का पल होता है। उसके बाद बस भूली जाती रहती है।

पर Obsidian में [[नोट का नाम]] लिखकर नोटों को आपस में जोड़ने की सुविधा है (इसे Wikilink कहते हैं), और जितना जोड़ो उतना यह एक नक़्शे जैसा बनता जाता है। “TypeScript की टाइप एरर” वाली नोट से “उस दिन फँसे Docker वाले किस्से” पर छलाँग, और वहाँ से “पिछले महीने की गड़बड़ी की समीक्षा” तक जुड़ाव। बिंदु लाइन बनते हैं, और लाइनें सतह। यही अहसास है।

मसला यह है कि यह जोड़-तोड़ इंसान करे, तो इतनी झंझटी है कि चलती ही नहीं।

यहीं काम AI को सौंपते हैं। ख़ास तौर पर, साथी के रूप में Claude Code नाम का औज़ार इस्तेमाल करते हैं। यह असल में कोड लिखने वाला AI है, पर असल में इसे “Markdown फ़ाइलों से भरे फ़ोल्डर को सुरक्षित ढंग से पढ़-लिख सकने वाला हेल्पर” के तौर पर इस्तेमाल किया जा सकता है। Obsidian की लोकल-फ़र्स्ट (फ़ाइलें आपके अपने PC पर) ख़ूबी वैसी-की-वैसी, और बस छँटाई की झंझट AI को सौंप दीजिए। यही आज की रणनीति है।

पर एक बात पहले ही कील की तरह ठोक दूँ। पूरे Vault पर AI को बदलने की अनुमति देना—यह बिल्कुल मत कीजिए।

.obsidian/ (सेटिंग फ़ोल्डर), छपे हुए लेख, क़रारनामे जैसी निजी नोट, API key—इन्हें AI से पढ़वाने की कोई वजह नहीं। इसलिए मैं “पढ़ना ज़रा खुलकर, लिखना बेहद सँभलकर” इस नीति से चलता हूँ। यह उसी सोच पर है जो मैंने पहले AI को काम सौंपने का “ढाँचा” कैसे बनाएँ में लिखी थी—यानी सहायक पहिए लगाकर ही दौड़ाओ, बस इतनी बात है।

ऐसी जगहों पर यह काम का है (तीन उदाहरण)

अमूर्त बातों से बात नहीं बैठती, इसलिए जिन तीन पलों में मुझे असल में “अरे, यह तो काम का है” लगा, वे रख देता हूँ।

पहला—सुबह की रोज़ वाली लॉग। हर सुबह, पिछले दिन की नोट AI से पढ़वाकर कहता हूँ—“जो काम अधूरे रह गए बस उन्हें आज पर खिसका दो, और कल की सीख तीन लाइन में निचोड़ दो।” फिर, कल के मैंने बिखेरे नोट, आज का मैं काम कर सकूँ ऐसी शक्ल में सजकर आ जाते हैं। “अच्छा, यह वही था जिसमें कल फँसा था” यह एक पल में याद आ जाता है। काम सौंपने वाला साथी, आने वाले कल का मैं ख़ुद हूँ।

दूसरा—कोड के टुकड़ों का बचाव। वही “दो साल पुरानी कमांड” वाली दिक्कत। snippets/ फ़ोल्डर में चली हुई कमांड डाल रखो, तो AI “यह किस काम की कमांड है?” वाला ब्योरा, और दूसरी मिलती-जुलती नोट के लिंक अपने-आप जोड़ देता है। नंगी कमांड, सर्च में मिल जाने वाली “ढंग की नोट” बन जाती है।

तीसरा—लेख के विषय की तैयारी। ब्लॉग लिखने के दिन, content-ops/ फ़ोल्डर की विषय-पोथी AI को दिखाकर पूछता हूँ—“इस लेख से किस पुराने लेख पर इंटरनल लिंक जोड़ा जा सकता है?” कभी-कभी वह छह महीने पुराना ऐसा लेख खींच लाता है जो मुझे ख़ुद भूल चुका था, और यह चुपके से बहुत काम आता है। बिंदु और बिंदु जुड़ने का वही पल।

मेरी अपनी तीन ग़लतियाँ

शायद असली मुद्दा यहीं से शुरू होता है। शुरू के कुछ हफ़्ते, मेरा Vault AI से ख़ूब उजड़ा। ईमानदारी से सामने रख देता हूँ।

पहली। एकदम से पूरे Vault को “छाँट दो” कह दिया। यह सबसे बुरी रही। AI दो साल पुरानी बेमतलब-सी नोट तक “मेहरबानी से” छाँटने चल पड़ा, और अपने मन से ढेरों टैग और शीर्षक उगा दिए। Graph view (नोटों का जुड़ाव दिखाने वाली स्क्रीन) अनजाने टैगों से भरा एक जंगल बन गया। पुरानी नोट का मतलब AI को आता ही नहीं। फिर भी अंदाज़े से चलता है। उसके बाद से, निशाना हमेशा बस एक फ़ोल्डर तक ही सीमित रखता हूँ।

दूसरी। नोट के नाम AI से अपने मन से बदलवा दिए। “शीर्षक, ज़रा साफ़ कर दो।” इससे [[पुराना नोट नाम]] वाले लिंक एक साथ टूट गए। Obsidian में ख़ुद नाम बदलें तो लिंक भी साथ-साथ बदल जाते हैं, पर बाहरी AI एक साथ फ़ाइल का नाम बदल दे, तो वह साथ-साथ बदलना काम नहीं करता। टूटे लिंकों की लाशें ही लाशें। अब “नाम बदलना हो तो इंसान से ज़रूर पूछो” यह फ़ौलादी नियम है।

तीसरी। private/ पढ़वा बैठा। यह तो कलेजा मुँह को आने से भी आगे की बात थी। क़रारनामे की रक़म वाली नोट का फ़ोल्डर, अनुमति सेटिंग में कोताही की वजह से AI के पढ़ने लायक हालत में था। हादसा हुआ नहीं, पर यह तो असली DB नए लड़के को नंगे हाथ छूने देने जैसा था। deny (मना-सूची) में ढंग से लिख रखा होता, तो हादसे की गुंजाइश ही न होती। सेटिंग में कंजूसी की, ग़लती अपनी—यही सबक़ है।

शुरुआत: बस तीन फ़ाइलें रखिए

मुश्किल कुछ नहीं। Vault के ठीक नीचे तीन चीज़ें रखनी हैं, बस।

पहले, फ़ोल्डर बाँटिए। शुरू से ही बहुत बारीक बँटवारा करेंगे तो वह ज़रूर बिखर जाता है, इसलिए मोटा-मोटा काफ़ी है।

# Vault के ठीक नीचे चलाएँ। रोज़ की जगह, प्रोजेक्ट, पब्लिश का काम और सुरक्षित इलाक़ा भर बाँटें
mkdir -p inbox daily projects content-ops snippets templates scripts archive private

हर फ़ोल्डर का काम, और AI को कहाँ तक सौंपना है, इसका बँटवारा मैंने ऐसा रखा है।

फ़ोल्डर	काम	AI को सौंपने का दायरा
inbox/	बिना छँटी नोट, वेब-क्लिप का पात्र	पढ़ना और नई बनाना
daily/	रोज़ की लॉग, काम की नोट	बनाना, जोड़ना, पिछले दिन का सार
projects/	चल रहे काम, हैंडओवर	बनाना, अपडेट करना, अधूरी बातें छाँटना
content-ops/	लेख के आइडिया, इंटरनल लिंक, पब्लिश जाँच	ड्राफ्ट सँवारना, लिंक जाँचना
snippets/	कोड के टुकड़े और इस्तेमाल	ब्योरा जोड़ना, टैग छाँटना
templates/	Obsidian टेम्पलेट	उसूलन पूछकर ही बदलना
archive/	पूरे हुए, सहेजे हुए	बदलना मना
private/	निजी जानकारी, क़रारनामे, राज़	पढ़ना तक मना

अब, Vault के ठीक नीचे CLAUDE.md रखिए। यह AI के लिए “हमारे यहाँ के नियम” लिखा काग़ज़ है। लंबा आदर्श बखानने से अच्छा है, निभाने लायक इनपुट-आउटपुट के नियम छोटे में लिखना, यही असरदार रहता है।

# Obsidian Vault के नियम

## भूमिका
- यह Vault रोज़ की लॉग, प्रोजेक्ट हैंडओवर, कोड के टुकड़े और लेख के आइडिया रखने की जगह है।
- private को पढ़े बिना भी काम का बना रहे, ऐसे चलना।

## फ़ोल्डर की नीति
- `daily/`: `YYYY-MM-DD.md` शक्ल में रोज़ की नोट बनाना और अपडेट करना।
- `projects/`: हर चालू काम के लिए एक हैंडओवर नोट बनाए रखना।
- `snippets/`: चली हुई कमांड, और उसकी पृष्ठभूमि तथा असफलता का उदाहरण साथ रखना।
- `templates/`: पढ़ना खुला है। बदलने से पहले ज़रूर पूछो।
- `archive/` और `private/`: मत बदलो। private की सामग्री का सार तक मत बनाओ।

## लिखने के नियम
- इंटरनल लिंक `[[प्रोजेक्ट का नाम]]` यानी Wikilink शक्ल में लिखो।
- नोट के शुरू में YAML प्रॉपर्टी (status वग़ैरह) लगाओ।
- एक पैराग्राफ़ पाँच लाइन के अंदर रखो।

## सुरक्षा के नियम
- मौजूदा नोट का नाम बदलना हो तो पहले ज़रूर पूछो।
- `.obsidian/` की सेटिंग मत बदलो।
- एक साथ ढेर सारा बदलने से पहले, निशाने वाली फ़ाइलें सूची में दिखाकर मंज़ूरी का इंतज़ार करो।
- बदलने के बाद ज़रूर `node scripts/audit-wikilinks.cjs .` चलाओ।

आख़िरी सबसे अहम है। .claude/settings.json से अनुमति को ठोस रूप से बाँध दीजिए। CLAUDE.md “गुज़ारिश” है, पर यह “ठोस ताला” है। तीसरी ग़लती दोबारा न हो, इसका दरबान। पढ़ना खुलकर, लिखना सिर्फ़ काम वाले फ़ोल्डर में, और ख़तरनाक काम deny से पूरी तरह बंद। सेटिंग का ब्योरा आधिकारिक अनुमति डॉक्युमेंटेशन में देखिए।

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

ये तीन काग़ज़ रख दिए, तो बाक़ी बस माँगना है। तरकीब यह है कि “ज़रा ढंग से छाँट दो” मत कहिए। दायरा, नतीजा, मनाही और जाँच तक, हर बार सब कुछ साफ़ बताइए।

daily/2026-06-04.md और projects/site-refresh.md पढ़ो।
templates/daily.md के आधार पर daily/2026-06-05.md बनाओ।
अधूरे काम, जिनका ज़िम्मा अब भी ख़ुद मेरा हो, बस उन्हें ही आगे खिसकाओ।
.obsidian/ और archive/ और private/ मत छूना।
बदलना ख़त्म हो जाए तो node scripts/audit-wikilinks.cjs . चलाकर नतीजा बताओ।

छोटा है, पर इसमें इनपुट, आउटपुट, मनाही का दायरा और जाँच कमांड सब आ गए हैं। “ज़रा ढंग से” से कई गुना ज़्यादा भरोसेमंद नतीजा।

आख़िरी दरबान: टूटे लिंक मशीन से जाँचना

बाहरी AI से फ़ाइल बदलवाओ, तो कभी-कभी Wikilink टूट जाते हैं। इंसानी नज़र से छूट जाते हैं। इसलिए आख़िर में, टूटे लिंक मशीनी ढंग से छाँट निकालने वाली स्क्रिप्ट बीच में लगा देता हूँ। इसे scripts/audit-wikilinks.cjs के नाम से सेव कीजिए।

#!/usr/bin/env node
// 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("टूटे/धुँधले इंटरनल लिंक मिले:");
  for (const problem of problems) console.error(`- ${problem}`);
  process.exit(1);
}

console.log(`ठीक है: ${vaultRoot} की ${markdownFiles.length} Markdown फ़ाइलें जाँच लीं`);

चलाना बस इतना।

node scripts/audit-wikilinks.cjs .

सारे लिंक ज़िंदा हों तो ठीक है निकलता है। टूटे हों, तो किस फ़ाइल का कौन-सा लिंक मरा है, सूची में बता देता है। AI ने छँटाई की, ठीक उसके बाद इसे चलाना—यही मेरी रोज़ की आख़िरी रस्म है।

वैसे, Obsidian की अपनी सुविधाओं (Daily notes, Templates, Properties, इंटरनल लिंक) के सटीक ब्योरे के लिए Obsidian की आधिकारिक मदद देख लीजिए। AI को सौंपने से पहले ख़ुद अपने जहाज़ की बनावट समझ लें, तो अटपटे निर्देश देने से बच जाते हैं।

असल में आज़माकर जो मिला

तीन महीने, इस इंतज़ाम से अपना Vault चलाकर देखा।

सबसे ज़्यादा असर, आख़िर में, “रोज़ की लॉग का हैंडओवर” और “पब्लिश से पहले लिंक जाँच” से ही मिला। सुबह सबसे पहले AI से पिछला दिन निचुड़वाता हूँ, तो इंजन साफ़ तौर पर जल्दी चालू होता है। “कल का मैं यहाँ अटका था” एक नज़र में दिखता है, इसलिए कॉफ़ी बनाते-बनाते दिमाग़ आज वाले मोड में चला जाता है। लिंक जाँच बीच में लगाने के बाद से, लेख छापने के बाद “अरे, इंटरनल लिंक तो टूटा था” वाली पीली रातें शून्य हो गईं। नंबरों में कहूँ तो, जाँच से पहले महीने में दो-तीन बार टूटे लिंक छप जाते थे, अब शून्य।

एक और अनसोचा फ़ायदा हुआ। AI को रोज़ छूने देने का इंतज़ाम बन जाने से, ख़ुद मेरे नोट लिखने का तरीका बदल गया। बाद में मशीन से पढ़वाना है, यह सोचकर अपने-आप status: लग जाता है, या कच्ची नोट में भी एक लाइन का सिलसिला जुड़ जाता है। AI के लिए सँवार रहा था सोचकर, आख़िर में सबसे पढ़ने लायक मेरा अपना ही इंसानी ख़ुद हो गया।

उलटे, शुरू में पूरा Vault एक झटके में छँटवाने वाला फेरा, साफ़ नाकामी रहा। पुरानी नोट का मतलब AI ने हद से ज़्यादा अंदाज़ा लगाया, और टैग तथा शीर्षक उलटे बढ़कर बिखर गए। नतीजा सीधा है—“अनुमति का दायरा तंग, टेम्पलेट पतला, और आख़िर में Node से जाँच”, ये तीन जितना निभाओ, उतना बढ़िया चलता है।

मज़ेदार यह है कि छह महीने पहले जिसे पक्के तौर पर याद न कर पाता, वह दो साल पुरानी कमांड, अब पाँच सेकंड में जा पकड़ता हूँ। AI ने जो लिंक जतन से जोड़े, मैं बस उन्हें चलता जाता हूँ। नोट, वाक़ई दिमाग़ बनने लगे हैं।

निचोड़

“नोट का अपने-आप पनपना” कोई जादू नहीं है। पढ़ना खुलकर, लिखना तंग, और आख़िर में मशीन से मिलान। इस ज़ाहिर-सी बात को बस एक इंतज़ाम बना दिया, इतना ही।

करना तीन काम है। फ़ोल्डर बाँटो, CLAUDE.md में नियम लिखो, और .claude/settings.json से ख़तरनाक काम ठोस रूप से बंद करो। बाक़ी बस “ज़रा ढंग से” न कहकर, दायरा सिकोड़कर माँगना है। आज पहले बस daily/ एक से शुरू कीजिए। आने वाले कल का आपका ख़ुद, थोड़ा हल्का महसूस करेगा।

अनुमति और सैंडबॉक्स की सोच और ब्योरेवार जाननी हो तो Claude Code की मंज़ूरी-सैंडबॉक्स डिज़ाइन भी देख लीजिए। हाथ चलाने लायक टेम्पलेट और टीम में लागू करने के परामर्श, शिक्षण सामग्री की सूची में समेटे हैं।