LLM Wiki Manager

A Claude Code skill for building and maintaining a personal LLM-managed wiki — a persistent, compounding knowledge base where the LLM does all the writing, cross-referencing, and bookkeeping while you curate sources and ask questions.

🇹🇷 Türkçe için README.tr.md

Quick Start

git clone https://github.com/sametbrr/llm-wiki-manager ~/.claude/skills/llm-wiki-manager

Start a new Claude Code session in your research folder:

mkdir ~/research/my-topic && cd ~/research/my-topic && claude
> "Set up an LLM wiki here. Topic: history of nutrition science."

Features

Instead of RAG — where the LLM rediscovers answers from raw documents on every query — this pattern has the LLM compile raw sources into a persistent, interlinked markdown wiki. Each new source enriches existing pages. Cross-references are built eagerly. Contradictions are flagged. Knowledge compounds over time.

Implements Karpathy's LLM Wiki pattern as a full Claude Code skill with 8 operating modes (including multi-wiki routing), 4 idempotent Python scripts, 8 page templates, and 9 reference documents.

Without this pattern          With this pattern
────────────────────          ──────────────────
Query 1 → re-read 50 docs     Query 1 → read compiled wiki (already synthesized)
Query 2 → re-read 50 docs     Query 2 → read updated wiki (cross-refs already there)
Query 3 → re-read 50 docs     Query 3 → read updated wiki (contradictions already flagged)

Requirements

• Claude Code or any agentskills.io-compatible agent
• Python 3.9+ (stdlib only, for the 4 included scripts — no pip install needed)

Installation

Option 1 — git clone (recommended)

git clone https://github.com/sametbrr/llm-wiki-manager ~/.claude/skills/llm-wiki-manager

Option 2 — GitHub CLI (requires gh CLI v2.90+)

gh skill install sametbrr/llm-wiki-manager

Option 3 — .skill file

curl -L -o llm-wiki-manager.skill \
  https://github.com/sametbrr/llm-wiki-manager/releases/latest/download/llm-wiki-manager.skill
unzip llm-wiki-manager.skill -d ~/.claude/skills/llm-wiki-manager

After installing, start a new Claude Code session. The skill loads automatically when relevant.

Usage

The skill auto-detects which mode applies from natural language. No slash commands needed.

Modes

Full walkthrough

# 1. Go to your research folder
mkdir ~/research/my-topic && cd ~/research/my-topic && claude

# 2. Bootstrap the wiki
> "Set up an LLM wiki here. Topic: history of nutrition science."

# 3. Drop a source
cp ~/Downloads/pollan-2008.pdf raw/

# 4. Ingest it
> "Ingest Pollan's In Defense of Food"

# 5. Ask questions
> "What does the wiki say about nutritionism?"

# 6. Health check (auto-saves dated report to wiki/reports/)
> "Lint the wiki"

The three-layer model

your-wiki/
├── CLAUDE.md          # Schema — conventions for this wiki (co-evolved over time)
├── raw/               # YOUR layer — immutable sources you curate. LLM reads, never writes.
└── wiki/              # LLM layer — all pages written and maintained by the LLM
    ├── index.md       # Content catalog (updated on every ingest)
    ├── log.md         # Append-only operation log (greppable)
    ├── hot.md         # Hot cache — most recently ingested sources and active references
    ├── sources/       # One summary page per ingested source
    ├── entities/      # People, organizations, places, products
    ├── concepts/      # Ideas, theories, frameworks, terms
    ├── notes/         # Filed-back query answers and loose pages
    └── reports/       # Auto-generated dated lint reports (wiki/reports/lint-YYYY-MM-DD.md)

Division of labor:

You almost never write wiki pages by hand. The LLM does the bookkeeping — that's what makes the wiki compound instead of collapse.

Core disciplines

1. LLM owns wiki/. You own raw/. No exceptions.
2. Every operation logs to log.md via append_log.py. Greppable: grep "^## \[" log.md | tail -20
3. Every new or updated page touches index.md via update_index.py. Stale index = wiki that feels lost.
4. Cross-reference aggressively. When a source mentions an entity that already has a page, update that page. Don't leave connections implicit.
5. Cite back to raw/. Every claim is traceable to a specific source file.
6. Flag contradictions, don't overwrite. New source disagrees with old claim? Both stay, marked with their source, with a > [!warning] Sources disagree callout.
7. Schema lives in CLAUDE.md. When a convention works, write it down. The next session starts informed.

What's inside

Scripts (Python stdlib, no dependencies, all idempotent)

Templates

Reference docs

Nine detailed workflow documents in references/:
philosophy.md · architecture.md · bootstrap-workflow.md · ingest-workflow.md · query-workflow.md · update-workflow.md · lint-workflow.md · schema-design-guide.md · multi-wiki-routing.md · teaching-mode.md

The skill reads these selectively — you don't need to. They're there to give the LLM depth on each mode.

Update mode

Standard ingest already handles contradictions on a single page (Disputes section). Update mode is for when a new source supersedes a claim that's paraphrased across multiple pages — the same idea written four different ways in four different files.

Scenario: Smith 2024 reanalysis shows Keys 1980's seven-countries study cherry-picked data.
The Keys r=0.87 claim appears as:
  concepts/saturated-fat.md     → "Keys found r=0.87 across seven countries"
  entities/ancel-keys.md        → "famous for showing strong correlation"
  concepts/heart-disease.md     → "saturated fat is a primary driver per Keys"
  concepts/dietary-policy.md    → "the saturated fat hypothesis drove decades of policy"

Update mode:
  1. Semantic sweep — finds all four (grep won't, LLM will)
  2. Shows scope: "4 pages affected. Proceed?"
  3. Diff-before-write per page — y/n/skip/edit per change
  4. Per-page strategy: revise / disputes / annotate (not one-size-fits-all)
  5. One log entry tying all four edits to Smith 2024

This is change propagation, not change tracking. The log and frontmatter track what was edited. Update mode ensures the edit reaches everywhere it should.

Auto-dated lint reports

lint_wiki.py with no flags:

• Writes wiki/reports/lint-YYYY-MM-DD.md (overwrites same-day run — idempotent daily)
• Adds a Reports index entry automatically
• Appends a lint | Health check log entry automatically
• Exits with code 1 if any block-severity issue found (useful for CI)

Reports accumulate as a longitudinal health record. git log wiki/reports/ shows how wiki quality evolved over time.

Override flags: --stdout (terminal, no tracking), --no-track (write file, skip index/log), --report PATH (custom path).

Multi-wiki

Most users start with one wiki. Once you have two — say, a per-project wiki at the working directory plus a long-lived global "second brain" (often an existing Obsidian vault) — the skill routes writes between them based on a single declaration in the project's CLAUDE.md.

~/projects/x-project/          ← active project (current working directory)
├── CLAUDE.md                  ← project schema — declares the global wiki path
├── raw/                       ← project sources
└── wiki/                      ← project wiki

~/Documents/obsidian/          ← global wiki (long-lived, exists across projects)
├── CLAUDE.md                  ← global schema
├── raw/
└── wiki/

One-time setup

Add this to the project's CLAUDE.md (or ask the agent to do it):

## External Wiki

Global knowledge base: ~/Documents/obsidian/

### Routing rules
- Project-specific code decisions, architecture, bugs, configuration → this project's `wiki/`
- Concepts, frameworks, patterns, ideas applicable beyond this project → global wiki
- When in doubt, ask before writing
- Scripts always need `--path` flag pointing to the right wiki root

### Cross-wiki links
- Use absolute paths (`~/...`) when linking from one wiki to the other.
- Never use relative paths that cross wiki boundaries.

Four canonical scenarios

Full walkthroughs of all four scenarios in references/multi-wiki-routing.md.

Compatibility

Related

• Karpathy's LLM Wiki gist — the original idea
• agentskills.io — open standard spec

License

MIT — see LICENSE.