# A Free LLM Wiki Template for Claude Code, Built From Six Months of Real Use

Free LLM wiki template for Claude Code: folder tree, /setup, lint.py size limits, versioned skills, and a simple Claude Project or Notion variant.

Topic: Claude & MCP
Published: 2026-11-06
URL: https://productivitytech.io/llm-wiki-template-claude-code/

This is the product page for the free [personal-memory template](https://github.com/Sinfjell/personal-memory-template): an **LLM wiki template** you can copy into a private repo and grow with Claude Code.

The architecture is the [five-layer Claude Code memory system](/claude-code-memory-system/) from March. After running that setup daily since spring, I audited it on **22 October 2026** — about **860** markdown files by then — and wrote up [seven failures and the rules that fixed them](/claude-code-memory-lessons/). This post is the template those rules shipped in: folder tree, `/setup`, the facts-vs-skills split, `lint.py`, and the no-code variant. Examples use **Acme** and **Example Client**, never real clients.

The measured before/after numbers below describe **my** knowledge base, not the empty public scaffold. The template ships the rules and the limits.

👉 [**Use this template on GitHub**](https://github.com/Sinfjell/personal-memory-template) — click *Use this template*, make the copy private, run `/setup`. Star the repo if it helps you keep the pattern around. Product page: [/products/personal-memory-template/](/products/personal-memory-template/).

## What you get (folder tree)

The full variant is a normal git repo. The layout matches what the public README shows:

```
personal-memory/
├── MEMORY.md          ← routing index (≤150 lines)
├── AGENTS.md          ← the one rules file (CLAUDE.md only imports it)
├── ORG.md             ← human review routine
├── log.md             ← this month's changes; older months in archive/log/
├── CHANGELOG.md       ← skill changes (Keep a Changelog + SemVer)
├── .claude-plugin/    ← plugin.json: version number for the skill set
├── skills/            ← setup, ingest, invoice-client (versioned)
├── clients/           ← entry file per client + a folder when it grows
├── companies/         ← your own companies
├── engineering/       ← patterns + debugging/ (one file per topic)
├── playbooks/  policies/  home/  projects/
├── scripts/lint.py    ← health check, standard library only
├── enkel/             ← simple Norwegian variant (Claude Project / Notion)
└── archive/           ← ignored by agents
```

`MEMORY.md` routes. Topic and client files hold the facts. `AGENTS.md` is the always-on rules file ([agents.md format](https://agents.md)); `CLAUDE.md` is only `@AGENTS.md`, the same pattern as in [CLAUDE.md too long](/claude-md-too-long/). `archive/` is ignored unless you ask for it.

## Start in five minutes with /setup

1. On GitHub, click *Use this template* (or clone the repo) and **make your copy private** — it will hold client data.
2. Open Claude Code in that folder.
3. Run **`/setup`**. It checks the repo is private, interviews you one question at a time (clients, invoicing, systems, recurring work), then creates the first client and company files, the index, and starter skills.
4. Point your global `~/.claude/CLAUDE.md` at the repo’s `MEMORY.md` so other projects can find the wiki.
5. After finished work, run **`/ingest`** so what you learned lands in the right files. That ingest idea is the same loop as in [Claude Code automation](/claude-code-automation/), scoped here to the knowledge base.

You do not start from a blank folder and invent the schema. `/setup` builds the first version; you edit from there.

## Facts in files, procedures in skills

Two jobs, two homes:

- **Facts** live in markdown files — `clients/acme.md`, quirks, deploy notes, decisions for Example Client.
- **Procedures** live in skills — `skills/invoice-client/SKILL.md`, `skills/ingest/SKILL.md`.

A client file points at a skill **by name** (for example `invoice-client`). The skill reads the client file. Neither copies the other. That split is why the rules file can stay short: always-on behavior in `AGENTS.md`, reference material in the wiki, steps in skills. Anthropic’s [Agent Skills best practices](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices) push the same direction — concise skill bodies, clear triggers, detail loaded on demand.

Durable facts do **not** belong in Claude Code’s project auto-memory folder. That index has a documented load window ([200 lines / 25 KB](https://code.claude.com/docs/en/memory)); when mine grew past it, the newest memories never reached a new session — full write-up: [Claude Code auto memory not working?](/claude-code-auto-memory-limit/).

## The guardrails: size limits and lint.py

Limits exist because the files that grow past them stop being useful. In my own knowledge base (22 October 2026 audit):

| What grew too large | Why it mattered |
| --- | --- |
| `MEMORY.md` at **305** lines / **60 KB** | The agent stopped treating the whole index as readable; after cleanup **133** lines + **3** sub-indexes |
| `CLAUDE.md` at **460** lines / **4,815** words | Cut to **195** lines — [CLAUDE.md too long](/claude-md-too-long/) |
| Auto-memory index at **202** lines | **13** newest never read → **102** lines, all **239** linked |
| Changelog at **1 MB**, **1,754** entries | Current month **37 KB**, rest archived |
| `debugging.md` at **327 KB** | One file nobody could search |
| Client files with **46** dated headings | Current state buried under diary entries |
| Dead links **31** | Quiet rot until a check ran |

The template’s `AGENTS.md` encodes the caps the lint script enforces: `MEMORY.md` ≤ **150** lines (rows ≤ 150 characters), client entry files ≤ **120** lines, topic files flagged over **40 KB**, `log.md` kept to the current month.

Run the check yourself:

```bash
python3 scripts/lint.py
```

It reports broken links, oversized index and entry files, skill version gaps, and related warnings. In **my** knowledge base a hook runs that script before every commit (dead links **31** → **0**). The **public template does not ship a pre-commit hook or a changelog generator** — only `scripts/lint.py` and a `CHANGELOG.md` you maintain. If you want the check on every commit, add a git hook yourself. The README’s standing advice is still: run lint monthly and fix what it finds.

## Versioned skills: ingest and invoice-client

The template ships three skills under `skills/`:

- **`setup`** — the `/setup` interview that builds the first wiki.
- **`ingest`** — after finished work: update the right topic files, one line in `log.md`, then lint.
- **`invoice-client`** — example domain skill: how to build an invoice draft for a client; it reads `clients/<slug>.md` instead of hardcoding Acme’s rules.

Each `SKILL.md` has a version line. Reading maps name the skill, not the version, so bumping a skill does not force edits across every client file. `.claude-plugin/plugin.json` holds one version number for the set; `CHANGELOG.md` records what changed.

In my own knowledge base, skills with a version went from **30** of **64** to all **64** in that October audit. Search recall on **20** test questions (right file in the top 3) went from **50%** to **85%** after the broader cleanup — including clearer files and better matching — not from the template alone.

## No code? The simple variant for Claude Projects or Notion

If you do not want a git repo, use the **`enkel/`** folder: a small Norwegian variant for a **Claude Project** or **Notion**. Same idea — one file (or page) per client for facts, a skill for the procedure — without `lint.py` or a routing index in the Claude Code sense.

- **Claude Project:** upload the client files and project instructions; re-upload when something changes.
- **Notion:** one page per client, connect Notion to Claude, keep the same facts-vs-steps split.

For a full personal task system in Notion (inbox, next actions, weekly review), that is a different job: [GTD Notion setup for 2026](/gtd-notion-setup-2026/). The simple wiki variant is only the client knowledge layer.

## How it differs from other LLM wiki templates

[Karpathy’s LLM Wiki gist](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) is the pattern this repo follows: immutable raw sources, a compiled wiki, a schema for how the wiki is written, plus ingest / query / lint as operations. Most generic “second brain” dumps stop at a folder of notes.

What this template adds on top of that pattern:

1. **One rules file** (`AGENTS.md`) with a Claude-friendly import, instead of drifting copies per tool.
2. **Hard size limits** checked by `scripts/lint.py`, not only documented as advice.
3. **`/setup`** so the first version of the wiki is interviewed into existence.
4. **Versioned skills** with facts kept out of the procedure files.
5. **A simple non-git variant** for Claude Projects or Notion.

It is a **Claude Code knowledge base** (and a Claude Code second brain, if you use that phrase) shaped by daily client work — not a RAG demo and not my private **860**-file tree. Clone the empty scaffold; bring your own Acme and Example Client facts.

👉 [**Use this template on GitHub**](https://github.com/Sinfjell/personal-memory-template) — *Use this template*, make it private, run `/setup`. Star the repo if you want it easy to find later.

Series context: architecture in the [March memory system post](/claude-code-memory-system/), measured failures in [7 lessons](/claude-code-memory-lessons/), then the [CLAUDE.md trim](/claude-md-too-long/) and [auto-memory load window](/claude-code-auto-memory-limit/). This post is the template itself.

[Subscribe below](#foot-sub) if you want template updates and later series posts by email.

## FAQ: LLM wiki template

<!-- faq -->