As a systems thinker, my mind is often sifting through bits of information, connecting ideas, and searching for underlying patterns. Much of this happens without conscious effort.

The mind is constantly seeking to make it—whatever it may be—make sense. Yes, it can be an annoying bug in the system. Feeling the need to obsessively collect every detail and understand how it fits into the broader context is like a hoarder cramming new boxes into a house, saying, "I'll organize it later."

There are a few problems with this:

1. It's incredibly time-consuming. Constantly reading, synthesizing, and storing new information is cognitively demanding work, often with little immediate payoff or usefulness that may not materialize until much later.

2. It's easy to confuse processing with progress. You can spend all your time collecting and organizing input without ever producing output. That's rumination, and that's certainly never useful.

Like I said, if left unchecked, this can become a bug, but it doesn't have to be. I built a system to do the following: catch, wrestle, and release.

I've tried to keep it as stupid simple as possible, drawing primarily from these key resources:

• Steph Ango's How I Use Obsidian for note structure and knowledge management.

• Karpathy's LLM Wiki for using an LLM as a partner to process and synthesize information faster.

Personal principles:

Before I dive into it, you should know my philosophy behind the system:

• Delegate the gist, never understanding. You only need the gist of most things. Use an LLM to quickly summarize, filter, and calibrate. But if it matters, read the source, wrestle with the ideas, and form your own judgment.

• Separate LLM-generated thinking from your own. Never mix them. Your knowledge base should clearly distinguish your original thinking from LLM-generated notes so both you and the LLM know what reflects your actual beliefs and reasoning.

• Always close the loop. Every exploration should end with a working conclusion. Document it and only revisit it when meaningful new evidence emerges. Never leave mental tabs open indefinitely.

Tools used:

• Obsidian

• Obsidian web clipper

• Claude Cowork

KB Architecture

Raw sources: This is where unprocessed inputs live.
Wiki: This is owned by the LLM. It has its own space to process, synthesize, and organize information.
Root-level notes: This is owned by me. It's my own space to do my own thinking, intentionally kept separate from the LLM's brain.

(1) Catch information

All assets I come across are downloaded or clipped using the Obsidian Web Clipper and placed in the raw/ folder. Mine consists mostly of essays, articles, tweets, and transcripts. From there, I ask the LLM to "ingest" the asset, prompting it to do several synthesis tasks:

• Read the raw asset.

• Create or update relevant notes in wiki/concepts and wiki/entities.

• Create a new wiki/sources note that summarizes the asset.

• Add the new wiki/sources note to the wiki/index.

Within the same prompt, it returns a quick summary of the wiki/sources note directly in the LLM interface. Going back to my personal principle: you only need the gist of most things. This helps me quickly calibrate and decide whether something deserves a deeper read or if I can leave it. It solves the problem of spending too much time reading things that are not worth the investment.

(2) Wrestle with the Wiki

This is where the personal wiki becomes valuable. The old way of using an LLM was to upload a few documents or references and retrieve an answer at the time of the query. Close the chat, revisit a similar topic later, and the context you built up with the LLM is gone.

With a personal knowledge base, I can run queries against a persistent wiki that compounds over time as I grow my library of raw assets and root files with my genuine thinking. If there is insufficient data in the wiki, the LLM will tell me to do more research instead of pretending to know.

(3) Release your thinking

Lastly, and what I believe is the most important step, is to close the loop. I create a root file with my own writing and thinking. Sometimes it becomes a published artifact. Most of the time, it doesn't. The point is to use your own thinking, give it a conclusion—even an imperfect one—and move on.

Do not keep mental tabs open. The bug loves to live here.

What next

My personal knowledge base serves two main purposes: (1) to improve my thinking, and ultimately my craft, and (2) to tend to my bug as a feature.

Using an LLM as a partner is a wonderful addition to help bookkeep and calibrate your understanding faster. But it should never replace genuine thinking, judgment, or the work of wrestling with ideas yourself.

If you're interested in the setup, view my github.