Here's something I've noticed: most people using AI are spending their tokens on code. I've shifted mine — a large fraction of my AI throughput now goes into manipulating knowledge, not code. Stored as markdown and images, maintained by an LLM, viewable in Obsidian.
This is the most underrated AI workflow I've found. And after running it for several months, I can tell you exactly what it looks like in practice and why I think someone is going to build an incredible product out of this pattern.
The short version: raw data from any source gets collected, then compiled by an LLM into a .md wiki, then operated on by various CLI commands for Q&A and enrichment — all viewable in Obsidian. You rarely write or edit the wiki manually. That's the LLM's job.
The pipeline, layer by layer
raw/Articles, papers, repos, datasets, YouTube transcripts, images — anything I want to think about ends up in a raw/ directory. I use the Obsidian Web Clipper extension to convert web articles into .md files. For YouTube, a hotkey downloads the transcript and related images locally so the LLM can reference them without fetching URLs in real time. The ingest step is intentionally frictionless — if it's too hard to add something, it won't get added.
This is where it gets interesting. I run a /compile-wiki command that reads everything in raw/ and does three things automatically on every file: a ghost analysis (what wasn't said — the implied idea, the contrarian read), a venture analysis (what business opportunity hides in this gap), and an idea pass (personal, actionable things I could do this week based on this content). The LLM then writes structured concept articles in 02-Concepts/ with backlinks, section images, and moves the raw files to 04-Resources/. I almost never touch the wiki directly.
I thought I'd need RAG (retrieval-augmented generation) once the vault got large enough. I don't — at least not yet. The LLM auto-maintains a VAULT-INDEX.md file and brief summaries for every document. When I ask a question, it reads the index first, identifies the relevant notes, reads those, and synthesizes an answer. At roughly 100 articles and 400K words, this works well without any vector embeddings or similarity search. The index is the trick.
Once the vault is large enough, you can ask complex questions and get answers that are grounded in your specific reading history — not generic web results. "What do I know about multi-agent orchestration?" "What connections exist between Jensen Huang's compute thesis and Andy McAfee's geek org framework?" "What are the venture opportunities hiding in everything I've read about AI policy enforcement?" The LLM goes off, researches the answers against your vault, and returns with citations. You can then file the answer back as a new concept article, which enriches the vault for future queries.
Instead of getting answers back in plain terminal text, I have the LLM render outputs as viewable artifacts — markdown files, Marp slideshows, or images — all of which I view again in Obsidian. The outputs often get filed back into the wiki to enhance it for future queries. Every exploration and question compounds. The vault grows smarter each time you use it.
Periodically I run LLM "health checks" over the vault to find inconsistent data, impute missing data via web search, and surface interesting connections for new article candidates. The LLM is quite good at suggesting further questions to explore — it will often flag a gap: "You have extensive notes on AI agents but nothing on agent security. Here are the three questions worth answering." That feedback loop keeps the vault coherent instead of just large.
The compounding effect: This is why the pattern is so powerful. Every query adds to the vault. Every lint pass improves it. Every new raw file gets synthesized against everything that already exists. A vault at 100 articles is exponentially more useful than the same vault at 10 articles — because the LLM is connecting nodes across the whole graph, not just summarizing individual files.
The IDE: why Obsidian specifically
I use Obsidian as the visual frontend for all of this. A few things make it the right choice for this workflow:
- Graph view — you can actually see the backlink graph the LLM builds. Clusters emerge visually that you wouldn't notice reading individual files.
- Local files — everything is plain
.mdfiles on disk. The LLM writes directly to the vault, no sync layer needed. - Plugin ecosystem — Marp renders the slideshows the LLM generates. Dataview turns concept articles into queryable databases. The Bases plugin creates structured views across the whole vault.
- You rarely touch it — this is the important part. The LLM writes and maintains all of the wiki data. I read it. Occasionally I add a raw file. That's the correct division of labor.
What the vault looks like at scale
My current vault on AI research has roughly 270 notes, organized into a structure the LLM maintains:
# vault structure (LLM-maintained)
00-Daily/ # daily notes — inbox for raw ideas
00-Inbox/raw/ # drop zone for new source material
02-Concepts/ # compiled wiki articles (LLM writes these)
03-People/ # person profiles with frameworks
04-Resources/ # processed source notes
VAULT-INDEX.md # master index — always read firstThe 02-Concepts/ directory is where the value lives. Each article has: a banner image, a core thesis, ghost notes (what wasn't said), venture opportunities (what business this implies), personal ideas (what I could do this week), and backlinks to related concepts. The LLM wrote all of it. I just asked questions and dropped raw files.
"I thought I had to reach for fancy RAG, but the LLM has been pretty good about auto-maintaining index files and brief summaries of all the documents."
The insight here is underappreciated: at small-to-medium scale (call it under 500K words), a well-maintained index beats a vector database for this workflow. The LLM's context window is large enough to hold the summaries, identify the relevant articles, and read them in full. Latency is the tradeoff — but for asynchronous knowledge work, it's irrelevant.
The extra tool I vibe-coded
As the vault grows, you naturally want to extend it with custom tools. I built a small naive search engine over the vault — available both as a web UI and as a CLI tool I can hand to the LLM for larger queries. The LLM uses it when a question spans too many notes to identify manually from the index.
This is where things get genuinely powerful: the LLM can now self-direct its own research against the vault. It uses the search tool to find relevant notes, reads them, synthesizes, and returns an answer — all without me specifying which notes to look at.
This is a raw set of scripts. Someone will build a real product from it.
The workflow I've described is a collection of Claude Code commands, Obsidian, and a few shell scripts. It works well — but it's fragile, personal, and requires a certain tolerance for manual setup. The product version would be seamless: web clipper → automatic compile → visual vault UI → instant Q&A → rendered outputs — all as a single coherent product instead of a duct-taped pipeline.
The companies closest to this — Notion AI, Obsidian Sync, Mem.ai, Roam Research — are all attacking it from the wrong angle. They're building better note-taking apps with AI bolted on. The right frame is inverted: it's an AI knowledge engine with a note-taking interface bolted on. The LLM is the primary worker. The human is the curator.
The further exploration that interests me most: synthetic data generation and fine-tuning, so the LLM eventually "knows" your vault in its weights — not just through context windows. That's when the leverage compounds into something genuinely new.
How to start
If you want to build something like this, the minimum viable version has three pieces:
- A drop zone — a folder where you put raw source material. No friction, no tagging, no organization. Just drop things in.
- A compile command — a prompt or script that tells the LLM to read everything in the drop zone and write structured concept articles. Give it a consistent format. I use the ghost + venture + idea lenses; you could use whatever mental models matter to your field.
- An index — instruct the LLM to maintain a single flat index file with a one-liner per note. This is what makes Q&A fast without RAG.
Start with 10 pieces of content you already want to think about. Run the compile step. Ask three questions you couldn't have answered without the synthesis. You'll immediately see whether this pattern is useful for your specific use case — and if it is, you'll know exactly how to extend it.
The key insight: you're not building a better note-taking system. You're building an AI that knows what you know — and can surface connections, gaps, and opportunities you'd never find manually. The notes are a side effect. The intelligence is the product.
I write when I find something worth writing about.
AI tools, enterprise GTM, and the occasional non-obvious synthesis. No filler.
