WWtGDO

Karpathy Method

6 min read

This backburner used to have a problem: I clip interesting articles and jot down ideas all the time, but nobody turned them into notes. They just piled up. The fix was the Karpathy Method, Andrej Karpathy’s “LLM wiki” pattern, where an AI agent does the librarian work. His framing: Obsidian is the IDE, the LLM is the programmer, the wiki is the codebase.

This is how I adapted it to this vault.

The architecture

Chrome Web Clipper ──┐
manual quick notes ──┴─> Clippings/   (raw, immutable, private)
                             │
                   /process-clippings  (a Claude Code skill)
                             ▼
                         content/     (the shelves) ──> visibles.info
  • Raw layer: a Clippings/ folder. Everything lands there with zero friction, web clips from the Obsidian Web Clipper, or notes I create by hand. Raw files are never edited, moved, or deleted.
  • Wiki layer: content/, the folder my static site generator (Quartz on Vercel) publishes. The skill derives short notes here from the clippings.
  • Schema layer: a SKILL.md file, the plain-text instructions that turn a generic AI agent into a disciplined librarian. Karpathy calls this file the most important part, and he’s right.

The rules that make it safe

The skill runs under hard rules, written into its instructions:

  1. Raw is immutable. The only edit allowed on a clipping is adding an ingested: "[[derived note]]" frontmatter flag once processed. To reprocess something, I delete the derived note and remove the flag.
  2. Hand-written notes are sacred. Derived notes carry derived_from frontmatter; anything without it is mine, and the agent may link to it but never touch it. One exception: notes named MOC * are indexes, and the agent may append wikilinks to them (never edit existing lines).
  3. Privacy boundary. The skill reads Clippings/, writes content/.
  4. No verbatim third-party text. Derived notes are syntheses in my own words with a link to the source, this is a public site, and other people’s articles are their copyright. A mode: verbatim flag exists only for texts I authored myself; non-English ones also get a linked (EN) translation twin.
  5. Short by default. A derived note is a dot, not an essay, longer only when the content earns it.

Folders here are note types, not topics: Dots, Sources, PJ, Expressions, Preguntes, Places, Receptes, HowTo. A note’s type never changes, so these folders don’t rot. Topics grow as links between notes, and when one gets big enough it earns a MOC note that maps it. The agent routes clippings by type (default: Dots), appends to MOCs, and never invents new folders, that’s my call.

How to use it day to day

Once in place, the whole system runs on three habits:

  1. Capture without thinking. See something interesting → clip it with the browser extension, drop a quick note into Clippings/ by hand, or just tell the agent: “create a clipping for Agenda 2030 on Dots, list all the goals” and /create-clipping researches it and writes the raw note for you. No filing, no formatting, no guilt.
  2. Optionally leave hints. If I already know where something belongs, I say so in the clipping (a line like “this is a recipe” or frontmatter). For my own texts that should be published exactly as written, I add mode: verbatim to the frontmatter.
  3. Every so often, run the agent. Open Claude Code in the vault and run /process-clippings. It scans for clippings without the ingested flag, derives notes into content/, updates MOCs, asks (in one batch) about anything it can’t route, and ends with a report of what went where. I review the new notes, tweak what I want, and the next git push publishes them.

There’s no schedule, the inbox can sit for weeks and nothing breaks, because raw never expires.

To redo a note: delete the derived note in content/ and remove the ingested line from its clipping, the next run rebuilds it from the untouched original. Useful after improving the skill’s instructions, which is the real tuning knob of the whole system.

The skills

The system runs on Claude Code skills, plain-text instruction files (SKILL.md) that turn the agent into a specialized tool. Mine, so far:

  • /process-clippings, the heart of the system. Scans Clippings/ for anything not yet ingested and turns each item into a published note: routes it to the right shelf, applies the source-type tag (Book, Podcast, Videogame…), adds the taxonomy axes when they’re obvious (a topic/ from the topic tree, a place/ when there’s a where, a time/ when there’s a when), creates any missing person, work or saga note so no reference dangles, appends new entries to the MOCs, marks the clipping as processed and leaves everything as drafts for my review. All the safety rules of this page are written inside it.
  • /create-clipping, capture by asking. Two modes: describe a topic, where it should go and what to include (“…list all the specific goals”) and it researches the facts (with sources) and writes the raw clipping; or just paste a URL and it clips the page for me, like the browser extension but from chat. It only ever feeds the inbox; publishing always goes through /process-clippings.
  • /lint-wiki, the health check, report-only. Hunts broken links and embeds, orphan notes, stale drafts, invalid frontmatter, forbidden characters, and validates every topic/, place/ and time/ tag against the registries in Workshop (unknown tags, malformed dates, notes that obviously deserve an axis they lack). It also proposes new topics or places when enough notes cluster around something the tree doesn’t cover yet. It fixes nothing; I decide.

The skill files are the real tuning knob: every rule in this HowTo, privacy boundaries, tags, quote conventions, draft-based review, is a sentence in a SKILL.md that I can edit in plain language.

Why it works

Capture stays effortless (clip and forget), the knowledge base compounds without my time, and every safety property is structural rather than hoped-for: raw and published are different folders, published and private are different folders, and git backs up everything. Setup cost, if you already run Obsidian + git + an AI agent: one afternoon of deciding the rules, one skill file.

Sources

Graph View

Backlinks