LLM Wiki
The single practice that most changed how I work with AI. Not a tool, not a framework — a pattern for building knowledge bases where the LLM does the bookkeeping and everything compounds.
What I was doing before
I was doing what everyone does. Dump documents into context. Prompt. Get an answer that's decent on the first question and falls apart on the third, because the model is rediscovering everything from scratch each time. Subtle questions — the ones that require connecting three sources — never got good answers because the connections evaporated between sessions.
I'd tried building wikis before, by hand. They all died the same way: the maintenance burden grew faster than the value. You add a source, and suddenly ten pages need updating. You do it once. You do it twice. By the fifth time you stop, and two weeks later the wiki is stale and you never open it again.
The pattern that changed it
Karpathy wrote up a pattern that reframed the whole thing for me. The core idea is simple, and it's the opposite of RAG:
Instead of retrieving from raw documents at query time, have the LLM incrementally build and maintain a persistent wiki. Each new source gets read, extracted, and integrated — cross-references updated, contradictions flagged, synthesis revised. The knowledge is compiled once and kept current, not re-derived on every query.
I adopted it immediately and haven't looked back. The difference in output quality is not incremental — it's a different category of result.
How I actually use it
My daily workflow: Obsidian open on one side, Claude Code on the other. The agent reads sources, writes wiki pages, maintains the index. I browse in real time — following links, checking the graph view, reading the updated pages as they appear. When I ask a question and get a good answer, that answer files back into the wiki as a new page. Everything compounds.
The part that makes this sustainable is the part I never have to do: the bookkeeping. One ingested source might touch ten or fifteen wiki pages — updating cross-references, revising summaries, flagging where new data contradicts old claims. That's the work that killed every wiki I'd ever tried to maintain by hand. Now it just happens.
The three layers
Raw sources
The curated collection of source documents — articles, papers, images, data files. Immutable. The LLM reads from them but never modifies them. This is the source of truth.
The wiki
A directory of LLM-generated markdown files. Summaries, entity pages, concept pages, comparisons, synthesis. The LLM owns this layer entirely — creating pages, updating them when new sources arrive, maintaining cross-references. I read it; the LLM writes it.
The schema
A CLAUDE.md (or equivalent) that tells the LLM how the wiki is structured, what the conventions are, what workflows to follow. This is what makes the LLM a disciplined wiki maintainer rather than a generic chatbot. I co-evolve this with the agent over time as I figure out what works for each domain.
Three operations
Ingest. Drop a new source, tell the LLM to process it. It reads, discusses takeaways with me, writes a summary page, updates the index, updates every relevant entity and concept page, appends to the log. I stay involved — I read the summaries, check the updates, guide emphasis.
Query. Ask questions against the wiki. The LLM searches pages, reads them, synthesizes an answer with citations. The important part: good answers get filed back into the wiki as new pages. Explorations compound just like ingested sources do.
Lint. Periodically ask the LLM to health-check: find contradictions, stale claims, orphan pages, missing cross-references. The agent is good at suggesting new questions to investigate and new sources to look for.
Why it actually sticks
The reason every previous wiki I'd built died was maintenance. The reason this one lives is that maintenance costs near zero. The LLM doesn't get bored, doesn't forget to update a cross-reference, and can touch fifteen files in one pass without complaining about it.
My job is to curate sources, direct the analysis, ask good questions, and think about what it all means. The LLM's job is everything else — the summarizing, cross-referencing, filing, and bookkeeping that makes a knowledge base actually useful over time.
Obsidian is the IDE. The LLM is the programmer. The wiki is the codebase.
Credit
The pattern comes from Andrej Karpathy, who wrote it up as an idea file designed to be handed directly to an LLM agent. I read it, handed it to my agent, and had a working wiki within the hour. The idea is related in spirit to Vannevar Bush's Memex (1945) — a personal, curated knowledge store with associative trails between documents. Bush's vision was closer to this than to what the web became. The part he couldn't solve was who does the maintenance.
I build AI systems inside businesses — context layers, system integrations, and internal tools that replace manual work. These notes are things I've learned doing it, published as I go.
LinkedIn · GitHub · More notes