Automatic Compilation Over Manual Curation

The historic failure of personal knowledge management is the curation tax. Every Zettelkasten, every PARA, every evergreen-notes vault asks the user to be a librarian — to summarise, link, refactor, periodically prune. Most people don't, and the systems collapse under their own raw-material weight.

LLMs change the calculus. Compilation — the work of turning raw input into structured, linked, searchable knowledge — was the most expensive step. It is now cheap enough to run on every ingest.

The principle

Compile automatically by default. Curate only at the points where human judgment is irreplaceable.

Every time something enters the system, the system:

• extracts the atomic facts
• links to existing entities and concepts
• detects contradictions with prior knowledge
• updates affected summaries

Without asking the user. Without waiting for a weekly review.

Why it matters

Manual curation is not just slow — it is unreliable. Humans forget which notes exist. Humans don't see connections across domains. Humans skip reviews when busy, and once a review is skipped, the backlog grows past the point of catching up.

Automatic compilation is reliable in a way humans cannot be. It runs on every ingest, sees every prior note, applies the same rules every time. The user's job shifts from librarian to editor: confirm, correct, reject — never originate the structure.

How it works

Two-pass:

1. Ingest pass — at write time, the agent extracts entities mentioned, atomic facts asserted, and links to existing knowledge. New entries are filed; existing entries get appended or rewritten.
2. Sweep pass — periodically (or on a trigger), an agent re-reads recent entries and looks for cross-cutting patterns: "the same concept got mentioned in three contexts this week — promote to a concept page" or "this insight contradicts something filed two months ago — surface for resolution."

The user reviews promotions and contradictions. The user does not write the summaries.

Immutable raw, mutable derived

Captured facts are immutable. They get superseded by newer facts; they do not get edited in place. The compiled artifacts on top of them — concepts, dossiers, summaries — are mutable, but every change is logged with who, when, and why.

The payoff is three-fold: ingestion is idempotent (re-running doesn't corrupt), the receipt of what was captured never changes (trust), and prior state is always reconstructable (forensics). Without this split, compilation quietly overwrites its own evidence.

In Claude primitives

• Hooks (PostToolUse, Stop) trigger the compile passes after each ingest event.
• Skills like extract-facts, find-contradictions, promote-concept carry the methodology in reusable form.
• Subagents run the sweep pass in parallel on different folders without polluting the main conversation.
• Long-context Sonnet/Opus (1M tokens) makes whole-vault re-reads economical.

Where I've seen it

In a personal KMS I use daily, the bouncer/promoter pipeline is automatic compilation in action — every inbound session note gets distilled, routed, and linked without user intervention. In a team KMS, the same pattern runs on every customer touchpoint. In an app-scoped second-brain KMS, the absence of automatic compilation is what made v1 feel like another note-taking app instead of a knowledge system.

The contrarian read

You give up the romance of "thinking by writing" — the slow, deliberate craft of weaving notes by hand. For most people that romance never produced compounding knowledge anyway; it produced beautiful note-vaults nobody re-read. Automatic compilation is the trade you make to actually have a working KMS.