Andrej Karpathy's Knowledge Management Method: 5 Principles Behind His LLM Knowledge Base System
Andrej Karpathy just shifted the way knowledge workers think about personal information systems. On April 3, 2026, the former Tesla AI Director and OpenAI founding member published "LLM Knowledge Bases"--a system where an LLM automatically builds, connects, and maintains a markdown wiki from raw sources. No RAG pipeline. No vector database. Just structured markdown files navigated by an index and summaries (GitHub Gist).
The system currently runs about 100 documents totaling 400,000 words. Karpathy's core claim is striking: "A large fraction of my recent token throughput is going less into manipulating code, and more into manipulating knowledge." That represents the latest stage in a progression from vibe coding (2025) to agentic engineering (early 2026) to knowledge manipulation (April 2026) (The New Stack).
But this didn't appear out of nowhere. Karpathy has been refining his knowledge management philosophy for 13 years--from Stanford study guides in 2013 to LLM-assisted reading in 2025 to this fully automated system. The underlying principles haven't changed. The tools have.
This analysis traces the full evolution, breaks down the technical architecture, and provides a practical framework for implementation.
Who Is Andrej Karpathy and Why His Approach Matters
Andrej Karpathy is one of the most influential figures in AI education and research. A Slovak-Canadian computer scientist, he earned his PhD at Stanford under Fei-Fei Li. He designed and taught CS231n, Stanford's first deep learning course, which grew from 150 students in 2015 to 750 by 2017--one of the most popular classes on campus (Wikipedia).
His career trajectory reads like a timeline of modern AI itself: OpenAI founding member, Tesla AI Director leading the Autopilot vision system, and in July 2024, founder of Eureka Labs--an AI-native education startup where AI Teaching Assistants provide 1:1 tutoring (TechCrunch). His YouTube series "Neural Networks: Zero to Hero" set a new standard for AI education by building GPT from a blank Python file (karpathy.ai).
When Karpathy shares a knowledge management system, it carries weight. He doesn't just theorize about learning--he has taught thousands and built production AI systems at the highest level.
The 13-Year Evolution: From Analog Learning to LLM Knowledge Bases
Karpathy's approach didn't start with LLMs. It started with pen and paper. Understanding the full timeline reveals why the current system works: it's built on battle-tested principles, not just new technology.
Phase 1: Analog Learning Principles (2013-2023)
In 2013, Karpathy published "Doing well in your courses" at Stanford. The core principles were foundational (Stanford CS):
- Sleep over cramming: "All-nighters are not worth it. Sleep works wonders." He recommended 7.5 hours of sleep and starting exam prep early to maximize the number of nights the brain processes material.
- Active recall over passive reading: "Reading and understanding is very different from being able to reproduce." Close the book. Write down the key ideas from memory. Derive the formulas yourself.
- Problems over textbooks: For quantitative subjects, "doing problems" explicitly takes priority over reading.
In 2020, he distilled this into a three-step formula for expertise shared on X: (1) Pick specific projects and learn deeply through repetition, using demand-driven rather than top-down learning. (2) Teach or summarize everything in your own words. (3) Compare only against your past self--never against others (X).
By February 2024, he mounted a sharp critique of "the shortification of learning." Short-form educational content on YouTube and TikTok looks like learning but functions as entertainment. His prescription: "Close the 'learn X in 10 minutes' tab. Find the meal--textbooks, papers, manuals. Block out 4 hours. Not just reading--note-taking, re-reading, restructuring, processing, manipulating, learning." Before consuming any content, explicitly declare: "Am I seeking entertainment or learning?" (X)
These principles--active engagement, structured processing, honest self-assessment--remain the foundation of everything that followed.
Phase 2: LLM-Assisted Reading (2024-2025)
In 2025, Karpathy revealed a new habit: reading everything with an LLM. Blog posts, articles, book chapters--all processed through a three-pass method (X):
- Pass 1 -- Manual reading: Read the source material yourself, start to finish.
- Pass 2 -- Explain/summarize: Ask the LLM to explain and summarize the key content.
- Pass 3 -- Q&A: Conduct a question-and-answer session with the LLM about the material.
He described this as achieving "better/deeper" understanding than simply moving on, calling it "one of the best growing use cases for LLMs."
The critical distinction: this is not "ask AI to summarize for you." Pass 1 requires manual reading first. The LLM augments active learning--it doesn't replace it. Karpathy's "intent declaration" principle (entertainment vs. learning) still governs the interaction.
Phase 3: LLM Knowledge Base System (April 2026)
The April 3, 2026 post represents the current culmination. The shift from "code manipulation" to "knowledge manipulation" is the defining statement (GitHub Gist).
The 3-Layer Architecture: How the LLM Knowledge Base Actually Works
The system uses three distinct layers, each with a clear ownership model (VentureBeat):
Layer 1: Raw Sources (Immutable, Human-Curated)
Papers, articles, images, datasets. The LLM reads these but never modifies them. They live in a raw/ directory. Obsidian Web Clipper converts web content to markdown, and images are stored locally so the LLM can reference them via vision capabilities.
Layer 2: Wiki (LLM-Owned)
LLM-generated markdown files: entity pages, concept summaries, topic overviews, cross-linked syntheses. The LLM has full ownership of this layer. A single source typically influences 10-15 wiki pages. The current wiki holds approximately 100 documents totaling 400,000 words.
Layer 3: Schema (Co-Evolved)
Configuration documents (like CLAUDE.md) that define wiki structure, rules, and workflows. Both human and LLM refine these over time through collaborative evolution.
Karpathy's LLM Knowledge Base architecture bypasses traditional RAG with an evolving markdown library. Source: VentureBeat
The 3-Step Core Workflow: Ingest, Compile, Maintain
Step 1: Data Ingest
Raw materials--papers, GitHub repositories, datasets, web articles--are collected into the raw/ directory. Obsidian Web Clipper handles web-to-markdown conversion. Images are stored locally for LLM vision access.
Step 2: LLM Compilation
This is the breakthrough. The LLM doesn't just index raw data--it compiles it. Specifically, it generates summaries, identifies key concepts, writes encyclopedia-style documents, and creates backlinks between related ideas. One source typically triggers updates across 10-15 wiki pages.
Step 3: Active Maintenance
The system is not static. The LLM runs "health check" or "linting" passes to identify inconsistencies across the wiki, fill missing data, and discover new connections. Q&A results are filed back as new wiki entries, so knowledge exploration accumulates in the knowledge base rather than vanishing into chat history.
The navigation structure relies on two key files:
- index.md: A categorized content catalog with one-line summaries and metadata for every wiki page. Updated by the LLM after each ingest.
- log.md: A chronological, append-only record using consistent prefixes like
## [2026-04-02] ingest | Article Title, parseable by Unix tools.
Karpathy's LLM Knowledge Base Gist--the blueprint for AI-maintained personal wikis. Source: GitHub Gist
Why This Beats RAG: The Structural Advantage
Conventional RAG systems retrieve raw documents at query time and feed them to the LLM for every interaction. Karpathy's approach front-loads the work: the LLM builds and maintains the wiki in advance, so at query time, it navigates already-structured knowledge.
Karpathy noted: "I expected to need a complex RAG pipeline, but at this scale the LLM can easily read and navigate relevant materials using just the index file and document summaries" (VentureBeat).
The key advantages:
| Factor | RAG Pipeline | LLM Knowledge Base |
|---|---|---|
| Query-time cost | High (retrieval + generation every time) | Low (pre-compiled knowledge) |
| Knowledge connections | Per-query, ephemeral | Persistent backlinks and cross-references |
| Maintenance | Manual pipeline updates | Automated LLM linting passes |
| Knowledge compounding | None--each query starts fresh | Cumulative--Q&A results feed back into wiki |
| Scale sweet spot | Large document collections (1,000+) | Small-to-medium collections (~100 docs) |
The caveat is real: this is validated at ~100 documents. At thousands or tens of thousands of documents, embedding-based retrieval may still be necessary. The practical strategy is hybrid: LLM Wiki for focused domains, RAG for large-scale retrieval.
The Tool Ecosystem: What Powers the System
Karpathy's stack is practical and specific:
- Obsidian: The IDE frontend--view raw sources, compiled wiki, and visualizations simultaneously (1.5M+ users)
- Marp: Markdown-based slide generation
- Matplotlib: Data visualizations rendered directly within Obsidian
- Dataview: Dynamic queries against YAML frontmatter for tables and lists
- qmd Search Tool: Local markdown search engine with BM25/vector hybrid search and LLM re-ranking
- Obsidian Graph View: Wiki connectivity visualization--identify hub pages, orphan pages, and overall structure
The progression from vibe coding to agentic engineering to knowledge manipulation. Source: The New Stack
5 Implementation Lessons from Community Adopters
Since Karpathy's post, multiple community implementations have surfaced. The practical lessons are valuable (VentureBeat, Antigravity Codes):
1. Classification First
Document type determines extraction strategy. A 50-page report and a 2-page letter need different processing. Classifying upfront saves tokens while improving output quality.
2. Token Budgeting
Allocate explicit token budgets by disclosure level: L0 (project context, ~200 tokens), L1 (index, ~1-2K), L2 (search results, ~2-5K), L3 (full document, 5-20K). This prevents context overflow.
3. Type-Specific Templates
Different entity types (people, events, documents, concepts) need different page structures. Community implementations converge on roughly 7 entity types as the practical sweet spot.
4. Dual Output Rule
Every task must produce two outputs: the direct deliverable plus updates to relevant wiki pages. Without this explicit schema requirement, knowledge evaporates into chat history.
5. Provenance Tracking
Use content hashing to detect source file changes. Mark compiled knowledge as "valid" or "stale" accordingly. This prevents knowledge rot--the silent degradation that occurs when source materials update but wiki pages don't.
Risks You Need to Evaluate Before Adopting
Technical Risks
- Scaling limits: Validated at ~100 docs/400K words. At thousands of documents, index.md navigation breaks down. Mitigation: Start small, add RAG layer when scaling.
- LLM hallucination: The LLM may synthesize information without sources or generate inaccurate content. Community implementations repeatedly flag this risk. Mitigation: Enforce source citations, run periodic spot checks, maintain human editor-in-chief role.
- Knowledge rot: Wiki pages don't automatically update when source materials change. Mitigation: Content hashing for change detection, regular linting passes.
Organizational Risks
- Role transition resistance: Moving from "author" to "curator" changes job identity. Mitigation: Prove value through pilot projects before expanding.
- Over-delegation to AI: Excessive automation may weaken critical thinking capabilities. Mitigation: Maintain Karpathy's principle--humans stay as curators and questioners.
Security Risks
- Confidential data exposure: Sending organizational knowledge to external LLM APIs creates data security risks. Mitigation: Use local LLMs or enterprise APIs (Azure OpenAI, AWS Bedrock). Filter sensitive data before processing.
The Meta-Principles: What Doesn't Change When Tools Change
Across 13 years of evolution, four meta-principles remain constant:
- Active Engagement: Never consume passively. Write it out (2013), ask the LLM to explain (2025), compile the wiki (2026).
- Structuring: Unstructured information never becomes knowledge. Cheat sheets (2013) became LLM summaries (2025) became wiki compilation (2026).
- Connecting: Isolated knowledge has low value. Collaboration (2013) became Q&A (2025) became backlinks and cross-references (2026).
- Compounding: Knowledge must grow with compound interest over time. Spaced repetition across nights (2013) became continuous wiki expansion (2026).
These principles are tool-agnostic. Whether you use Obsidian, Notion, or pen and paper, the framework applies.
What Happens Next: Short, Medium, and Long-Term Outlook
Short-term (3-6 months): The LLM Knowledge Base pattern will spread rapidly among individual researchers and early adopters. The Obsidian ecosystem is already producing plugins and MCP servers (gnosis-mcp, library-mcp) to support this workflow (Antigravity Codes).
Medium-term (1-2 years): Enterprise knowledge management tools will integrate the pattern. Expect Confluence, Notion, and similar tools to add "auto-compilation" features--or watch purpose-built tools emerge. Karpathy's vision of "fine-tuning models on curated personal wikis for true personalization beyond context windows" will see early attempts (HowAIWorks.ai).
Long-term (3+ years): Combining Eureka Labs' AI Teaching Assistant model with LLM Knowledge Bases creates a "knowledge-to-education pipeline." An organization's wiki could automatically compile personalized onboarding programs when new team members join.
Frequently Asked Questions
What is Karpathy's LLM Knowledge Base and how does it differ from RAG?
Karpathy's LLM Knowledge Base is a system where an LLM automatically builds, maintains, and cross-links a markdown wiki from raw source materials. Unlike RAG, which retrieves raw documents at query time, this approach pre-compiles knowledge into structured wiki pages. The LLM navigates using an index file and document summaries rather than embedding-based retrieval. It's validated at approximately 100 documents and 400,000 words (GitHub Gist).
Can I build an LLM Knowledge Base with Obsidian today?
Yes. The minimum setup requires Obsidian as the frontend, a structured directory (raw/ for sources, wiki/ for LLM-compiled pages, _meta/ for schema), and access to an LLM (Claude, GPT-4, or similar). Obsidian Web Clipper handles web-to-markdown conversion. Community-built MCP servers like gnosis-mcp are emerging to automate the workflow (Antigravity Codes).
What are the biggest risks of using an LLM to maintain a knowledge wiki?
The three primary risks are hallucination (LLM generating unsourced information), knowledge rot (wiki pages becoming stale when sources update), and scaling limits (the index-based navigation breaks down beyond ~100 documents). Mitigations include enforcing source citations, content hashing for change detection, and adding RAG layers for large-scale collections (VentureBeat).
How does Karpathy's three-pass reading method work with LLMs?
The method has three sequential passes: (1) Manual reading--read the source yourself, (2) Explain/summarize--ask the LLM to explain the key content, (3) Q&A--conduct a question-and-answer session with the LLM. The critical point is that Pass 1 (manual reading) always comes first. The LLM augments active learning rather than replacing it (X).
Is this approach suitable for enterprise-scale knowledge management?
At its current scale (~100 documents), the system works without RAG. For enterprise-scale deployments with thousands of documents, a hybrid approach is recommended: LLM Wiki for focused, high-value domains combined with traditional RAG for large-scale retrieval. The key insight is that the LLM Knowledge Base pattern is most powerful when applied to curated, high-importance knowledge rather than bulk document storage.
Key Takeaways
Karpathy's knowledge management system works because it combines 13 years of validated learning principles with LLM automation. The human stays as curator and questioner. The LLM handles organization, connection, and maintenance. Knowledge compounds over time instead of decaying in chat histories.
The practical starting point is clear: pick one research domain, collect 10-20 sources, set up the minimum directory structure (raw/wiki/schema), and let an LLM compile the first iteration. Evaluate the results, refine the schema, and expand from there.
The organizations that adopt this pattern early will build knowledge at compound interest rates while competitors continue losing insights to scattered documents and abandoned wikis. The underlying principles are timeless. The tools have finally caught up.
Published by AboutCoreLab AI Research Team | April 6, 2026
Sources:
- Andrej Karpathy, "LLM Knowledge Bases" (GitHub Gist, 2026-04-03): GitHub Gist
- VentureBeat, "Karpathy shares 'LLM Knowledge Base' architecture that bypasses RAG" (2026-04-04): VentureBeat
- HowAIWorks.ai, "Building Personal Knowledge Bases with LLMs: The Karpathy Method" (2026-04-04): HowAIWorks.ai
- Antigravity Codes, "Karpathy's LLM Knowledge Bases: The Post-Code AI Workflow" (2026-04-04): Antigravity Codes
- Andrej Karpathy, "Doing well in your courses" (Stanford CS, 2013): Stanford CS
- Andrej Karpathy, "How to become expert at thing" (X, 2020-11-07): X
- Andrej Karpathy, "Reading with LLMs habit" (X, 2025): X
- Andrej Karpathy, "On shortification of learning" (X, 2024-02): X
- The New Stack, "Vibe coding is passe" (2026): The New Stack
- TechCrunch, "After Tesla and OpenAI, Karpathy's startup aims to apply AI to education" (2024-07-16): TechCrunch