Karpathy+

Your AI forgets everything between chats. So you re-explain your projects and how you like things done, again and again. And the notes you keep for it go stale, so it works off the wrong version of reality and you don't notice until something is already wrong.

One word first: "context" just means everything the AI can see in a single conversation. It is the working memory for that chat, and it resets the moment the chat ends.

This gives your AI a shared memory that sticks between chats and stays correct over time. A handful of plain files, plus a few rules that keep them honest. You can build it in an afternoon.

New to this? The next two sections are the why. Ready to build? The download up top hands your AI everything it needs to set this up for you.

00The whole system, on one plate

Three kinds of files. Three habits. One rule about where things live, and a few cheap tripwires so nothing rots quietly. That's the whole thing.

01Most systems like this die young

They die one of three ways. Every design choice on this page exists to dodge one of them.

02Raw at the bottom, rules on top

Raw clippings at the bottom. The pages you'd hand a new assistant in the middle. House rules on top, about 50 lines of them.

The AI never reads the whole pile. It reads the rules, an index, and the two to four pages today's work needs.

03One rule about where things live

One rule prevents the three-copy drift problem before it starts:

Knowledge goes in ~/AI/. Runtime goes in ~/.claude/.

Inside the knowledge side, nothing sits loose at the root. Every file has a named drawer: the wiki, project folders, an inbox for the unsorted, a scratch pile for the throwaway. The archive lives outside the fence, so searches stay clean.

04Write it down, look it up, check it weekly

Ingest

After a fix, a decision, or a correction, the AI updates the page and appends to the log with a Judgment: line, one sentence on why. The why is what future sessions actually use.

## 2026-06-08 -- moved the archive out of the search path
Searches kept surfacing dead drafts. Moved the archive outside
the knowledge folder; results are clean again.
Judgment: scoped tools decide where files live. State the
scope before filing anything.

Write the why, not just the what.

Query

Each session loads about 50 lines of rules, an index under 50 lines, and two to four pages. That's the whole reading list, so there's no four-hundred-line rulebook to skip when the chat gets long.

One caveat: a plan is not enough context on its own. Load the pages it references first. Details are in the build guide.

Lint

Once a week, one command runs the whole checklist: stale pages, broken links, unprocessed notes, forgotten tasks. It fixes the mechanical stuff and asks you about the rest. You answer do it, defer it, or kill it.

The full checklist is in the build guide.

Flag once via lint. Build infrastructure only when the pattern fires twice.

05Several small nets, not one big one

Discipline alone fails during fires. So the system stacks several independent nets, each cheap and a little dumb.

One blind spot: every net above reads files. None can see whether a scheduled job is actually running. So each scheduled job declares an expected output, and a verifier asks one dumb question: did today's file appear?

The completion gate is the last net: nothing is done until the change works and the docs say so.

06Copies drift. Links don't.

The moment a fact leaves the wiki, the copy stops updating. The AI's own notes, pasted instructions, last month's plan: all snapshots. So check copies when you use them, not when you make them.

Where possible, remove duplicated facts from copies and point them to the wiki. A hardcoded page count will drift. A link cannot.

07What it can't do

Naming the gaps beats pretending the system is airtight.

08Build yours in an afternoon

The pattern is general. Anyone can adapt it.

Minimum viable wiki, five steps

Keep these (universal)

Three layers. The boundary rule. An index as the front door. A log with Judgment: lines. The weekly check. The completion gate.

Adapt these (local)

Page categories to your domains. The check's schedule. Your task tracker. Everything surface-specific.

The whole thing is a folder you can push to git, which is what lets scheduled agents read it from the cloud. The build guide has the step.

The system grows by use. Add a page when you catch yourself repeating context. Everything past the minimum is earned by need, not added by default.

stuck mid-build? a real human answers · I set up systems like this for individuals and small teams · entropyeq@gmail.com

09What's next, honestly

Planned, not built.

• Plans will carry a freshness stamp, so a stale plan can't pass as a current one.
• The weekly check will diff every claim in the AI's private notes against the wiki, not just the easy ones.
• Real search lands when the wiki outgrows grep, around fifty pages.

The system stays small on purpose.

The system works, and building it taught me a lot. I'm still looking forward to replacing most of it.

10Where the ideas came from

The compounding principle is the spine. The wiki pattern is the skeleton. The boundary rule, the nets, and the completion gate are my answer to the failure modes each source named but didn't fully close.