Don't Let the AI Be Your Only Way Into Your Notes

The AI is a view on your notes; the folder underneath is the truth. Keep the folder reachable — cd ~/notes && rg <term> — so the chat window is a convenience, not the only door. Rehearse the two-command drill before the day the tool is slow, down, or deprecated. That day is when your dependency shows.

The failure mode is quiet and recent. You go to ChatGPT, Claude, Cursor, or Copilot Chat to find that thing you wrote last month, the tool is slow or paid or down or deprecated, and for a beat you realize you do not remember which folder or file it is in. The notes are still there on disk in plain Markdown; only the view on top is gone. The discipline this post walks through is architectural — two layers, both live, so neither is a single point of failure. The AI stays; the folder stays reachable without it.

Why the folder has to be reachable without the AI

The folder has to be reachable without the AI because a view can disappear and a filesystem cannot. A chat window with your notes indexed inside it depends on a vendor UI, a session, a network, a model, and a subscription; a folder of Markdown files depends on the filesystem your OS ships with. Two failure boundaries, not one.

The durable substrate is older than the tool you are using this year. POSIX find and grep are normative in the Open Group Base Specifications Issue 7, 2018 edition (IEEE Std 1003.1-2017): "The find utility shall recursively descend the directory hierarchy from each file specified by path, evaluating a Boolean expression"¹ and "The grep utility shall search the input files, selecting lines matching one or more patterns"². Standardized since the early 1990s, the tools themselves are older; they ship with every Unix-like OS — macOS, Linux, WSL — and they run offline, without an account, an API key, or a model. That is the retrieval floor.

The two-command drill is one line each. find ~/notes -name '*.md' | xargs grep -l 'term' prints the files that contain the term; grep -rn 'term' ~/notes | head prints the matching lines with filename and line number. Andrew Gallant's ripgrep is the same substrate with faster defaults and gitignore awareness — on his canonical benchmark, on the linux_literal workload over a built Linux kernel checkout, rg (ignore) 0.334 +/- 0.053 seconds against ag (ignore) (mmap) 1.588 +/- 0.011, pt (ignore) 0.456 +/- 0.025, sift (ignore) 0.630 +/- 0.004, and git grep (ignore) 0.345 +/- 0.007³. Sub-second on a corpus vastly larger than any personal notes vault, on one machine, with no server and no network. A notes vault is a rounding error next to that.

The durability datapoint on the tool itself is public and cheap to re-derive. The BurntSushi/ripgrep repository — curl -sL "https://api.github.com/repos/BurntSushi/ripgrep" — reports 65,768 stars, license Unlicense (public-domain), created 2016-03-11, updated 2026-07-04⁴. Public-domain licensing means the tool cannot be rug-pulled: if the canonical repository ever goes dark, someone can fork the source and rebuild it. Andrew Gallant himself named the tool as a superset of two long-lived Unix ancestors: "ripgrep, that combines the usability of The Silver Searcher (an ack clone) with the raw performance of GNU grep. ripgrep is fast, cross platform (with binaries available for Linux, Mac and Windows) and written in Rust."⁵ The retrieval substrate you rely on is inherited, standardized, and independent of any AI vendor's fate.

Even the retrieval-accuracy case for grep is now peer-reviewed evidence. Wang et al.'s February 2026 paper GrepRAG: An Empirical Study and Optimization of Grep-Like Retrieval for Code Completion (arXiv:2601.23254 v2) reports: "In the Python subset under the DeepSeek-V3.2-EXP setting, our method achieves an EM rate of 38.61%, substantially exceeding the traditional Vanilla RAG (24.99%) and RLCoder (36.59%)" — with "the average retrieval latency of less than 0.02s" for Naive GrepRAG⁶. The paper is a code-completion benchmark, not a notes benchmark, so the direction transfers rather than the numbers — the same paper that says grep-plus-LLM matches or beats a vector pipeline on code says nothing about your notes vault directly. The result falsifies the assumption that vectors are required for any retrieval an LLM consumes⁶. Sibling post Don't Build a RAG Over Your Vault. Grep It. carries the personal-vault case at length⁷.

The two-layer discipline: view on top, folder underneath

The discipline is two layers, both live. The AI view is the fast, forgetful, convenient layer — a chat window you ask English questions. The filesystem view is the slow, honest, durable layer — a folder you can list, cat, and grep from any shell that ships with your OS. When the top layer disappears, the bottom layer still works.

Steph Ango — the same Steph Ango who runs Obsidian — put the general shape in one paragraph in File over app: "File over app is an appeal to tool makers: accept that all software is ephemeral, and give people ownership over their data. In the fullness of time, the files you create are more important than the tools you use to create them. Apps are ephemeral, but your files have a chance to last."⁸ Restated at the AI layer: the AI you use to reach the files is a tool; the files are the thing that lasts. Ango is not a competitor to any AI vendor; he is naming the pattern that outlives whichever vendor you pick.

The reframe that makes the discipline stick is the log-and-view analogy from Ishaan Sehgal, writing on dev.to/dailycontext in The Log Is the Agent: "Every operation on the agent either reads the log, appends to it, or renders a view of it. The model reads a view and produces the next action. The tool runner executes a tool call and appends the result. The UI reads the log and renders a timeline; the tracing system reads it and renders traces; an auditor reads it to reconstruct what happened."⁹ Rewritten for the note-taker: the AI is a view that reads and renders your notes; the notes themselves are the log. If the view goes away, the log is still there and still legible in a text editor.

Ink & Switch's Onward! 2019 paper Local-first software: you own your data, in spite of the cloud — Kleppmann, Wiggins, van Hardenberg, McGranaghan — names the ideals a chat-window-only interface violates by construction. The seven ideals, verbatim: "1. No spinners: your work at your fingertips 2. Your work is not trapped on one device 3. The network is optional 4. Seamless collaboration with your colleagues 5. The Long Now 6. Security and privacy by default 7. You retain ultimate ownership and control"¹⁰. A chat-window-only interface to your notes fails at least ideals 2 (your work is trapped in one vendor's UI), 3 (the network is required to reach the notes), 5 (The Long Now — the tool is on a shorter deprecation cadence than your career), and 7 (the vendor holds the router between you and your file). The two-layer discipline does not violate them — the folder underneath is the ownership.

The five-minute version: cd, rg, and one export

Five minutes and a package install — the smallest version that keeps the folder reachable. Confirm the folder is grepable from a shell. Install ripgrep. Point your AI tool's sessions to a location under ~/notes/ so the transcript is a file you can grep too. Three lines and one habit; the AI stays where it is.

1. Open a terminal, then cd ~/notes — or whatever folder holds your Markdown. The point of the step is to confirm the folder still is where you think it is, and to make the two-command drill muscle memory.
2. Run the drill once, with a term you know is in the vault: rg -n 'coffee grinder' | head. The -n prints line numbers; head caps the output. If the wrong file scrolls past, find ~/notes -name '*.md' -newermt '2026-07-01' -print narrows by date.
3. Install ripgrep on any machine where it is missing (brew install ripgrep on macOS, apt install ripgrep on Debian/Ubuntu, scoop install ripgrep on Windows). Public-domain license, cross-platform binaries⁴⁵; it is a one-line install and a one-time cost.
4. Schedule an AI-session export into ~/notes/ai/. Vendors already write local session files (see §5 below); the move is to copy them into a location you list, back up, and grep alongside your regular notes.
5. Rehearse the no-AI drill once. Turn wifi off. Open a shell. Reach for a specific note by memory plus grep. You will find out in ninety seconds which notes are legible outside the vendor's UI and which are not.

That is the five-minute version. The folder is the source; the regex is the retriever; the AI is a view you may or may not have on hand. When the vendor UI is not there, the notes still are.

The thirty-minute version: an ~/notes/ai/ mirror and a quarterly no-AI drill

The thirty-minute upgrade is the same drill with three additions — a scheduled export of AI sessions into ~/notes/ai/, a shell function that makes the two-command drill one keystroke, and a calendar reminder to rehearse the no-AI drill once a quarter. Each is a one-time cost. Together they keep the folder reachable when the tool is not.

Point the vendor's session files at a folder you own. Anthropic's Claude Code, for example, writes JSONL session files locally by default — enough of a documented pattern that Simon Willison wrote a converter for them. His claude-code-transcripts (Apache-2.0, 1,598 stars, created 2025-12-24)¹¹ does the readable-HTML conversion; his own framing is the point: "There's one problem: the actual work that I do is now increasingly represented by these Claude conversations. Those transcripts capture extremely important context about my projects: what I asked for, what Claude suggested, decisions I made, and Claude's own justification for the decisions it made while implementing a feature."¹² The tool exists because the vendor's own UI is not the only door — someone had to write a plain-text extractor for the local JSONL files. The pattern generalizes to your notes: your files deserve at least this level of fallback.

Wrap the drill in a shell function so the retrieval floor is one keystroke away. notes() { rg -n "$1" ~/notes | head; } in your shell rc file is enough. Add a companion function for the AI-session mirror once the export is running — airg() { rg -n "$1" ~/notes/ai/ | head; } — and the fallback becomes a habit rather than a fire drill. The functions never touch the network; they never call a model; they never expire when the vendor changes pricing.

Schedule the no-AI drill quarterly. Put it on the calendar the way you would put on a fire drill. Turn wifi off, open a shell, reach for a specific note by memory plus rg. The rehearsal is the whole point — the day you need the drill is not the day to learn it. Two rehearsals in a year is enough to keep the muscle memory alive, and it will surface any note that only lives inside the vendor's UI in time to fix it.

Common mistakes

Five common mistakes account for almost every "I lost access to my notes when the tool changed" story — hiding the folder behind the app, letting the AI be the only retrieval path, letting AI sessions live only in the vendor's UI, filing everything as one giant note, and skipping the rehearsal. Each is a one-line fix.

• Hiding the folder behind the app. The folder is the source of truth; the app is a view. If you cannot find your notes in a shell, the app is a wrapper, not an editor. The move is to know the path — most likely ~/notes, ~/Documents/Notes, ~/Obsidian/* — and to keep the vault as plain files the OS can list.
• Treating the AI as the primary retrieval interface. Reaching for a chat window before grep is fine on a good day and disastrous on the day the tool is slow, down, paid, or deprecated. The two-layer discipline says the AI is layered on top of a retrieval path you keep live, not instead of one. Run rg at least once a week so the muscle memory is there.
• Letting AI sessions live only in the vendor's UI. If your working record is in a chat log you cannot list, back up, or grep from a shell, the vendor is holding the router. The fix is a scheduled export into ~/notes/ai/ — the Willison move, generalized¹¹¹². Willison wrote the exporter because the vendor's UI was not the only door; write your version for whichever vendor you use.
• Filing everything as one giant note the folder cannot help with. A single notes.md file with a year of thoughts fails the drill: grep returns every line, head returns the top of the file, and the folder does not disambiguate. Split by date, project, or topic — anything the filesystem can index — and the drill starts working. Sibling Find Your Notes by Searching, Not Organizing is the extended argument¹³.
• Skipping the rehearsal. The drill is worthless if you have never run it. Every quarter, turn wifi off and reach for one specific note. Two rehearsals a year is enough to prove which parts of your workflow depend on the vendor UI and which do not — and the failure mode is cheap when you find it during a rehearsal, not when you find it during an outage.

An honest scope: the AI does win on some retrieval, but a view is still not a door

The AI does earn its keep on some retrieval. Marco Somma's 2026 benchmark reports both sides: on average the "Brain" scored 8.39 versus 8.27 without it — technically positive, not the kind of number you name a new era over¹⁴. For most everyday "where did I write about X" retrieval, a well-organized folder plus rg is already at the ceiling.

Somma writes the framing plainly: "Brain scored 8.39. Brainless scored 8.27. That is a +0.12 difference on a 10-point scale. Technically positive, but not the kind of result you use to announce that persistent memory has unlocked a new era of agent intelligence unless your relationship with evidence is mostly decorative."¹⁴ The average case is a tie; the two-layer discipline holds.

The one track where the AI did win is worth naming. Somma continues: "Only one track survived: the long same-domain sequence. In that track, the Brain won 74% of the time even when placed in the disfavored position."¹⁴ Same-domain reasoning across long sequences — a legitimate case where the AI view earns its keep, and this piece does not claim otherwise. Even so, the architectural point holds: a view that wins on top of a folder still cannot be the only door. When the view goes away, the folder is what remains; the AI is a convenience layered on that, whether it wins on the average day or the 74th percentile.

Two caveats to keep visible. First, GrepRAG's grep-beats-vector result is a code-completion benchmark on CrossCodeEval and RepoEval-Updated, not a notes benchmark⁶ — the direction transfers, the exact numbers do not. Second, Ink & Switch's seven ideals are ideals; the paper's own scoring table shows Files + email attachments hitting five of seven, not seven of seven¹⁰. This piece is arguing that a chat-window-only interface violates at least ideals 2, 3, 5, and 7. It is not claiming all seven are trivially met — nor that the drill solves AI-tool lock-in. The drill makes lock-in cheaper to walk away from.

How this works in MNMNOTE

MNMNOTE stores your notes as plain Markdown on your own device — the app is a view; the folder is the truth. You can quit the app, open a shell, and run rg -n 'term' <path> against your MNMNOTE folder without touching the app. It is the same drill this post walks through.

Sharing, when you choose it, is end-to-end encrypted; the AI features you opt into send the text you choose to your chosen provider (bring-your-own-key). MNMNOTE is described by capability, not by exclusive benefit — the drill here is the same drill you would run on any plain-Markdown vault. That is the point. The tool is a view; the folder is the truth; keep the folder reachable — with MNMNOTE, with Obsidian, with a plain ~/notes directory. The discipline is architectural.

Frequently Asked Questions

How do I search my notes vault without opening the app? Open a terminal, cd into the vault folder, and run rg -n 'term' | head (or grep -rn 'term' . if rg is not installed). Any Markdown vault — Obsidian, MNMNOTE, a plain ~/notes folder — is a folder of .md files the OS can grep directly. The app is a view; the folder is the truth, and the OS ships with the tools to read it.

How do I find a note if ChatGPT or Claude is down? The notes are still on disk in plain Markdown; only the view on top is gone. cd ~/notes && grep -r 'term' . returns the matching lines; find ~/notes -name '*.md' -newermt '2026-07-01' -print narrows by date. Both commands are POSIX and run offline without an account or an API key. This is why the drill exists — the day you need it is not the day to learn it.

Is grep faster than ChatGPT for finding a note? For lexical retrieval on a personal vault, yes, and the answer stays on your machine. ripgrep returns sub-second on a Linux-kernel-sized corpus³; a chat round-trip is dominated by network and model latency. For a genuinely conceptual query whose words you never wrote down, a vector pass with an LLM on top is often better — but for "where did I write about X" queries, grep is faster and the failure mode is legible.

What happens to my notes if my AI tool shuts down? The notes are still on disk. Only the view on top is gone. The two-layer discipline exists so the moment the vendor UI disappears — outage, deprecation, pricing change, corporate exit — the folder is still reachable with cd and grep. Rehearse the no-AI drill quarterly to confirm which of your notes live only in the vendor UI and fix that before the day you need them.

How do I export my Claude Code or ChatGPT session to a file? Use the vendor's own export first — Anthropic's Claude Code writes JSONL session files locally by default, and OpenAI ChatGPT offers Settings → Data controls → Export data. Simon Willison's claude-code-transcripts (Apache-2.0, 1,598 stars) converts the local JSONL into readable HTML¹¹¹². The move to make afterwards is copy the exported files into a location you list, back up, and grep alongside your regular notes — usually ~/notes/ai/. Sibling post Copy Your AI Memory List Into a File You Own is the read-side companion¹⁵.

Can I use find and grep on my notes? Yes — find and grep are POSIX standards, normative in IEEE Std 1003.1-2017¹², and they ship with every Unix-like OS: macOS, Linux, and WSL on Windows. They run offline, without an account, an API key, or a model. If your notes are .md files on disk, the OS you already use can find and grep them directly.

Does the AI make my notes better or does it just replace the folder? Both are possible; only one is safe. The AI is genuinely useful for some retrieval — long same-domain reasoning is the honest case (Somma's benchmark: 74% win in that track)¹⁴. The architectural discipline is: add value with the AI, but do not depend on the AI to reach the notes. The AI is a view on top of the folder; the folder is the truth. Keep the folder reachable and both layers stay live.

The tool is a view; the folder is the truth. Keep the folder reachable — the day you need cd ~/notes && rg is not the day to learn it.

MNMNOTE (mnmnote.com) keeps your notes as plain Markdown on your own device, so the two-layer drill in this post is the same drill you can already run on your vault today.