My AI Has a Better Memory of Me Than I Do

What it looks like day to day

It keeps my to-do list. And here's my favorite part: a to-do list was never part of the design. One day I just said "you should keep a to-do list for me", and the AI added one. Made the note, wrote itself the rules for using it, done. Now I say "add that to my list" in any conversation, phone or laptop, and it's there for every future one. When I ask "what's on my plate?", it knows. Items get checked off with a date. Its own housekeeping even flags new items onto the list when something needs my decision. That's the real shape of this thing: it's not a fixed set of features, it's a memory that grows whatever you ask it to grow. If a to-do list sounds like one more thing to remember to check, you simply never ask for one.

It tells me what it's remembering. When something worth keeping comes up, it says so in one line ("memory updated: ...") so I always know what's being written down about me. I can also open the folder and read every word it believes, which is more than I can say for any other memory feature I've used.

It remembers how I like things done. I mentioned once that I hate time estimates in project plans. I have never seen one since. Dozens of little preferences like that have quietly piled up, which is why working with it feels less like prompting and more like working with someone who knows me.

When I catch it making a mistake, the mistake stays fixed. It doesn't just apologize. It writes itself a rule so that kind of mistake can't quietly come back. My corrections add up, and it is noticeably better behaved than it was two months ago. The AI model didn't change. The notes did.

It works while I sleep. Every morning at 6:30, a scheduled job re-reads yesterday's conversations and files anything we forgot to save. Every Tuesday another one tidies the whole folder, looking for duplicates, stale facts, and contradictions, then leaves me a short report. I didn't hire staff. I wrote two sets of instructions. (Honesty note: the scheduling itself is a feature of my AI's paid plan, not of the folder. The brain just gives those scheduled runs something worth doing. If your AI can't schedule tasks, everything else on this page still works. This part is the bonus.)

What it costs, and who owns it

Nothing, and me (you, in your case). The notes are ordinary text files I can read, edit, and copy. They sync to my phone through the cloud drive I already had; that's things like Google Drive, Microsoft OneDrive, or Dropbox, and if you use any of those, you already own everything this needs. When the AI app updates and wipes its settings, which happens more than you'd think, the folder doesn't care. And if I ever switch to a different AI entirely, the memory comes with me, because any AI that can read files can read my folder. Nothing about my life is locked inside somebody's product.

Why not Obsidian?

If you've googled "second brain" you've already met Obsidian, a much-loved note-taking app and a fine one. Its notes are plain text files in a folder, the same bones as mine. I skipped it for one practical reason: getting your notes onto your phone the official way is a subscription (Obsidian Sync runs $4 to $5 a month), and the free workarounds are the fiddly kind that break at the wrong moment. My folder rides the cloud drive I was already using. It costs nothing and it just works.

The bigger realization is that the app was never the point. The AI doesn't need Obsidian. It needs the folder. If you already love Obsidian, keep it: point your AI at your vault and everything on this page still works. If you don't, you never needed it.

What this is really the start of

Here's the part I didn't expect: the memory turned out to be the foundation, not the feature. Once your AI actually knows you, other doors open one after another.

It stops being a search box and starts being something closer to staff. If your AI plan can schedule jobs, it starts acting without being prompted; mine does its own filing before I wake up. A to-do list it owns means real delegation, where I can park a task in March and any conversation in May picks it up. Corrections that become rules mean fewer mistakes every week, so your AI gets better even when the model doesn't. Old decisions keep their receipts, since nothing gets overwritten, only updated with a dated note, and months later I can ask "what did we decide about that, and why?" and get the real answer. Projects stop dying between chats, too. I recently published four websites in two days, mostly because every session started out already knowing everything the last one knew.

I'm not saying this is the way. To each their own, and plenty of people are happy with their AI as a goldfish. But if you've ever wished yours felt less like a very smart stranger, this is the cheapest fix I know of, and the prompt below will have your AI build the whole thing for you. You don't need to be technical. That's rather the point.

What you'll need

Honesty section, because plan features matter here. (Checked July 2026, and these things change fast.) The full self-maintaining version needs an AI that can read and write files in a folder on your computer. Today that generally means a paid plan with file access, like Claude's desktop app ($20/month), which is how mine runs. One truly free exception exists for the adventurous: OpenAI's Codex CLI comes with a free ChatGPT account and can run the whole pattern, though it lives in a terminal and the free limits are tight. And there's a manual mode that works on every free tier: keep the folder of notes yourself, paste the table of contents at the start of a chat, and copy the AI's updates back into your files by hand. You become the file system. Tedious, but completely free, and the folder still outlives every app and subscription. The prompt below handles all three cases, and it checks what your AI can actually do before promising anything.

For the technical reader

Everything below is the machinery behind the story above: the load path, the rules, how this compares to the systems you've probably read about, and the builder prompt itself. If you just want the memory, skip to the prompt and paste it. Your AI reads it so you don't have to.

The load path

In a normal chat setup, only two inputs survive from one session to the next: a small block of custom instructions, and whatever the AI chooses to read once the session starts. So the always-on layer here holds zero facts. It's a pointer that says "read the manifest first," short enough to retype in ten seconds if an app update ever wipes it. The manifest is the index: core facts up top, a routing table saying which file to open for which kind of task, and the rules. (Mine currently runs a bit over a hundred lines; yours will be whatever yours needs.) Everything else stays on disk until a task needs it. An index the AI actually follows turns out to be enough.

The rules that make it trustworthy

A few rules do most of the work. Save the durable criterion instead of the passing instance ("wants a two-bedroom under $1,800 near transit", not the listing itself). When a conversation produces a useful answer or a piece of research, that gets saved as its own note instead of scrolling away into chat history. Every fact is written once, in one place, with a date and a note of where it came from. And before writing anything down, the AI decides who the fact is actually about, so a detail about my brother gets filed under my brother, not under me.

Facts also carry trust levels. Things I said outrank things the AI concluded. Inferences are labeled with their reasoning, and anything captured by an unattended job is tagged (mined, unreviewed) until I confirm it. A wrong guess that gets written down without a label becomes tomorrow's confident hallucination, so the labels are what keep it honest.

Nothing is allowed to vanish. Every overwrite gets a timestamped backup first. Values are superseded with a dated note instead of replaced. Deletions need my explicit sign-off, every change is logged, and every write is verified afterward, because file tools on cloud-synced folders really do truncate files silently while reporting success. And when I correct a mistake, a rule gets written against that whole class of error, with incidents tracked so a failed prevention gets noticed and escalated.

The maintenance layer

Two scheduled instructions keep it clean. A daily one mines recent conversations for anything worth keeping that live capture missed. A weekly one audits the folder for duplicates, contradictions, stale dated facts, and sync-conflict copies, asks me to confirm the unreviewed items, surfaces open questions and dropped threads, and puts anything needing a human decision onto my to-do list (a feature mine only has because I asked). Both sets of instructions live inside the brain itself, where an app update can't reach them. Cross-domain questions run through one more text file, a list of labeled connections like truck-project --needs--> workshop-rewiring, which the AI searches to trace how things relate in either direction.

A field guide to AI memory (and where this sits)

The clearest map of this territory is the five-level taxonomy from Nate Herk's video Every Level of a Claude Second Brain Explained. His L2 takes both its name and its shape from Andrej Karpathy's "LLM Wiki" (first card in the next section). Each level exists to answer a question the one below it can't:

His advice, and the best single sentence in this whole genre, is to take the lowest level that kills your actual pain. If nothing hurts, don't build more. (He runs his own brain at L2.)

Mine is L2 with one organ borrowed from L4 and two toes in L5: a text wiki at the core, a plain file of labeled connections standing in for a graph engine, and the two scheduled jobs doing the only slice of "autonomous" that has earned its keep. I skipped L3 entirely, on purpose. More on that in the limits.

The systems I actually evaluated (and what I stole)

These comparisons all came after the build, mostly to check whether anyone had solved something I hadn't. Notice the pattern in the verdicts: what got stolen were conventions, a tag here and a habit there, never the architecture. Full credit where I looted:

Why boring text files win (at this scale)

1. Any tool can read it. A folder of text files is the most portable data format ever shipped. Switch assistants or vendors and the memory comes along. Every database is a future migration; a folder is a copy-paste.

2. You can read it. Every belief the AI holds about me is a line I can open, audit, and fix. When memory is wrong in an embedding store you get vibes. When it's wrong in a text file you get a diff.

3. Token economy. Always-on cost: two short paragraphs. Per-session cost: one index of about 130 lines. Per-task cost: only the files the task routes to. Nothing loads because it might be relevant. Things load because the index says they are.

4. Zero infrastructure. No server, no API keys, no subscription, no schema migrations, nothing to breach. The only runtime is an AI that can read files, which is the one dependency I already had.

5. It survives everything. App updates wipe settings? The pointer is one sentence, retyped in seconds. Sync client forks a file? The weekly scan catches it. A write truncates? Verified, then restored from backup. The system assumes entropy and budgets for it.

6. Curating at write time beats archaeology at read time. Storing everything and sorting it out at retrieval is a bet that search will always beat mess. At personal scale it's cheaper to never make the mess. Distill facts as they arrive and every later read is small, fast, and already correct.

The honest limits

There's no semantic search, so recall depends on sane naming and routing. If I ask about "compensation" and the file says salary, the search needs luck a vector index wouldn't. The rules are enforced by an AI following instructions, not by a database engine, so a sloppy model can misfile things; the backups, verification, and audits exist precisely because of that. It's single-user by design, so don't run a team wiki or a hundred thousand documents through it. And it costs a short setup conversation plus the habit of letting the assistant actually maintain it.

Build your own in about ten minutes

You don't need to understand a line of what's in the box below. It's addressed to your AI, not to you, and it tells the AI to walk you through everything gently, one step at a time. Paste it into an AI assistant that can read and write local files (Claude's desktop app or Claude Code today; adapt freely for anything else). It interviews you, builds the folder, writes the rules into the manifest, wires the bootstrap, and proves the load path works. Also available as a raw text file.

Copy prompt# Build me a second brain (persistent AI memory out of plain files)

You are going to build me a persistent memory system — a "second brain" — made of plain
markdown files, so you can remember me across sessions. This works on any AI assistant that
can read/write local files and accepts standing instructions (Claude Cowork, Claude Code,
and similar). No database, no embeddings, no cloud services.

FIRST, check your own hands: confirm you can actually read and write files in a folder on
my computer, across sessions. If you can't (many free plans can't), say so plainly and offer
MANUAL MODE instead: you'll generate every file's contents in chat for me to save myself,
and at the start of future chats I'll paste the MANIFEST (and you'll ask for any deeper
file you need). Everything below still applies — I'm just the file system.

IMPORTANT — assume I may not be technical. Work ONE step at a time and wait for me before
the next. Before each step, say in one plain sentence what it does and why. Whenever I have
to do something outside this chat (find a folder, paste something into settings), give me
exact click-by-click directions for MY platform, then check my result before moving on.
Translate any jargon the moment you use it.

## Step 1 — Interview me first (wait for my answers)
1. Where should the brain live? (a local folder; if I use multiple devices, put it inside my
   cloud-sync folder, e.g. Google Drive/Dropbox/OneDrive)
2. What should you call me, and what are 3–5 core facts you should always know about me?
3. What do I most want remembered? (preferences, projects, people, health, all of it?)
4. Is there anything you should NEVER store? (Honor this list forever.)

## Step 2 — Create this structure
<root>/
  MANIFEST.md            <- the index: core facts + routing table + the rules below
  self/profile.md        <- durable facts about me
  people/_index.md       <- one file per person in my life, indexed
  preferences/_index.md  <- my tastes and criteria, one file per domain
  topics/_index.md       <- recurring subjects/projects, one file each
  system/                <- job prompts, templates, scripts
  backups/               <- timestamped pre-overwrite copies (mirrors the tree)
  inbox/                 <- capture drops from devices that can create but not edit files
  log.md                 <- dated, newest-first record of every change

## Step 3 — Write these rules INTO MANIFEST.md (the rules ARE the system)
1. PROGRESSIVE DISCLOSURE: only this manifest loads by default. Open deeper files only when
   the task needs them. The manifest holds ~10 core facts, a routing table ("file — open
   when ..."), and these rules. Keep it under ~150 lines forever; push detail down.
2. RECALL: before any task touching my tastes, people, projects, or past — check the
   relevant file first. I should never have to repeat myself.
3. CAPTURE: when I state a durable, reusable fact, write it to the right file immediately
   and tell me in one line ("memory updated: ..."). Save the CRITERION, not the instance
   ("wants 2BR under $1800 near transit", not "looked at apartment on 5th St").
4. ONE FACT, ONE PLACE: each fact lives in exactly one file; other files point to it.
5. SUBJECT RESOLUTION: decide WHO a fact is about before writing. Me -> self/. Someone
   else -> their people/ file. Never conflate. Ambiguous -> ask.
6. DATE EVERYTHING CHANGEABLE, with source: `job_title: PM (2026-07, told directly)`.
   Store roots, not derivatives (birth date, not age). Mark your own inferences as
   (inferred, from what) — never as something I said.
7. NEVER SILENTLY LOSE DATA: before overwriting or removing ANYTHING, copy the file to
   backups/<path>.<UTC-timestamp>.bak. Update values by SUPERSEDING: new value + a dated
   changelog note preserving the old one. No deletes without my explicit OK, ever.
   Add a dated line at the TOP of log.md for every change (newest first).
8. FILE FORMAT: every fact file = `key: value` facts up top (flat snake_case, greppable), then
   "## Notes (newest first)", then "## Changelog" (dated).
9. SCALING: when a file nears ~300 lines, split it into <name>/_index.md + shards and
   update pointers.
10. TRUST TIERS: anything written by an unattended/automated pass is tagged
    `(mined YYYY-MM-DD, unreviewed)` until I confirm it. My directly-stated facts outrank
    mined or inferred ones.
11. VERIFY EVERY WRITE: afterwards, confirm the file grew as expected and its last line is
    intact (sync clients and file tools can silently truncate). On failure: restore the
    backup and rewrite. If truncation EVER happens, stop using the file-editing tools on
    that folder entirely — size doesn't predict safety — and route every write through
    the shell/code sandbox instead (ideally a small script with backup + byte-verify +
    auto-restore built in).
12. TURN CORRECTIONS INTO RULES: when I catch you missing something or correct a mistake,
    don't just fix the instance — find what would have prevented that CLASS of error and
    add it (a rule here, a checklist step, a verification). If the same miss happens twice,
    the first prevention failed — escalate. A fix without a prevention is a mistake I'll
    have to catch again.


## Step 4 — Wire the bootstrap (this is what makes it load every session)
Give me a short block to paste into my always-on layer (custom instructions / user
preferences / CLAUDE.md / a skill description) that says ONLY:
  "My persistent memory lives at <root>. Before responding to anything about me, my
   preferences, projects, people, or past conversations, read MANIFEST.md there and follow
   it. Everything about me lives in those files, not here. If you can't reach the folder,
   say so plainly — never guess about me."
ZERO personal facts go in that block — always-on layers are exactly what app updates wipe.
If my platform has two such layers (e.g. instructions AND a skill), wire both; either one
alone should be enough to load the brain.

## Step 5 — Prove it works
1. Generate a random passphrase (two words + number), save it in MANIFEST.md as
   `loadcheck_token`, and tell me what it is.
2. Make sure I've pasted the Step 4 block into my settings first; then I'll open a FRESH
   session and ask: "what's my loadcheck token?" A correct answer — arrived at by READING
   the manifest, not by built-in chat memory — proves the load path. (A file-read tool
   call first is normal; that IS the mechanism.)
   (MANUAL MODE: the test still works — I paste my MANIFEST into the fresh chat and you
   find the token in it; and in Step 4's block, swap "read MANIFEST.md there" for "ask me
   to paste my MANIFEST".)
3. Then interview me for ten minutes — life, preferences, current projects — and file
   everything per the rules, as my starter corpus.

## Step 6 — Offer these power-ups (my choice, don't force them)
- topics/todo.md — my running to-do list: add items when I say "add that to my list",
  check it when I ask what's pending, mark items done with a date. This alone makes the
  brain feel like an assistant instead of a filing cabinet.
- DAILY CONSOLIDATION job (if my platform has scheduled tasks and can read past session
  transcripts): re-read recent conversations, capture durable facts that inline capture
  missed, tag per rule 10, dedup before writing (grep first; supersede, don't restate).
- WEEKLY AUDIT job: find duplicates, stale dated facts, contradictions, oversized files, and
  derived values stored where the root belongs (an age instead of a birth date); surface
  unreviewed facts for my confirmation, plus open questions and dropped threads; propose
  fixes in a report — never auto-delete.
- relationships.md: a map of how things relate, one connection per line (`thing
  --how-it-relates--> thing | note, date`), searched (grep) when I ask how things
  connect across domains.
- If I use a phone: phone sessions CREATE dated note files in inbox/ (they usually can't
  safely edit); the daily job files them properly later.

Build it now: do Step 1, then everything else, then hand me the bootstrap block and my
loadcheck token.

Two tips from the scar tissue: put the folder inside your cloud-sync folder on day one (that's My Drive for Google Drive users, or your OneDrive folder), because future you has a second laptop, and actually run the fresh-session loadcheck test. A memory system you haven't tested loading is a diary, not a brain.