AI-augmented PKM: taming the information firehose

You subscribe to the RSS feeds. You follow the repos. You bookmark the articles. And three months later you have 400 unread tabs and no idea what you actually learned. The volume of new tools, frameworks, protocols, and papers in tech is growing faster than any human can process — and cognitive load research confirms that when mental burden exceeds capacity, errors increase and the quality of your work drops.

Ironically, AI tool adoption makes this worse. The 2025 DORA Report found that engineers now juggle prompt engineering, solution architecture, and validating AI-generated outputs on top of their existing workload. More tools, more cognitive overhead.

So how do you turn the firehose into something useful? You build a system. Here is mine.

The stack

My personal knowledge management (PKM) setup uses four tools, each handling a different part of the workflow:

• Google NotebookLM — deep research, synthesis, and learning from source material
• Git repo + Claude Code — the knowledge base itself, managed through the terminal
• Obsidian — reading and browsing the same repo with graph views and wiki links
• Craft.do + MCP — quick capture and extraction from any conversation with Claude

None of these are mandatory. The principle matters more than the specific tools: capture widely, process with AI, store in plain text, connect relentlessly.

NotebookLM: your research engine

Google NotebookLM is the best starting point when you need to actually learn something rather than look up a quick answer. You upload your sources — PDFs, web URLs, Google Docs, YouTube videos, audio files — and it grounds every response in those sources, not general training data. Every claim links back to where it came from.

The feature set goes beyond chat:

• Audio Overviews turn your documents into podcast-style conversations between two AI hosts. You pick the tone — deep dive, critique, debate — and it generates a listenable summary you can interrupt with follow-up questions.
• Mind maps auto-generate visual topic graphs from your sources. Click a node to expand sub-topics with AI-generated summaries.
• Study guides, flashcards, and quizzes — useful for certifications or learning new protocols.
• Learning Guide mode acts as a personal tutor, asking probing questions and breaking concepts into steps.

NotebookLM does not replace web search. It replaces the tedious part of reading, cross-referencing, and synthesizing multiple sources into understanding. CNET called it “possibly the most practical AI product.” That tracks with my experience.

Git repo + Claude Code: the knowledge base

The core of the system is a Git repository full of markdown files. That is it. No proprietary database, no SaaS lock-in. Plain markdown in a folder structure managed by Git.

Why this works:

• Markdown is the native language of LLMs. Every AI tool reads and writes it natively. No conversion, no export, no friction.
• Git gives you version history. Every change is tracked. You can diff your knowledge base over time, roll back mistakes, and sync across machines.
• Claude Code operates directly on the repo. It reads your notes, creates new ones, updates tags across hundreds of files, finds notes that should be linked, and surfaces thematic connections you missed.

The setup is minimal:

A CLAUDE.md for a knowledge vault looks something like this:

# Knowledge Vault

## Core principles
1. Everything is Markdown — portable, future-proof, AI-readable
2. One idea per note (Zettelkasten style)
3. Use wiki links: [[note-name]]
4. Frontmatter (YAML) at top of every file
5. Process inbox weekly — don't let raw captures pile up

## Tag taxonomy
- #concept — core ideas and mental models
- #tool — software, libraries, services
- #workflow — repeatable processes
- #reference — specs, RFCs, documentation summaries

You can define Claude Code custom slash commands (Skills) for common operations: /trace to surface patterns across notes, /connect to find linking candidates, /ghost to draft a note from bullet points. These turn repetitive knowledge work into one-line commands.

Obsidian: the reading layer

The same Git repo that Claude Code manages opens directly in Obsidian. No sync, no import — you point Obsidian at the folder and it renders your markdown with graph views, bidirectional links, and the full plugin ecosystem.

Claude Code is your writer and librarian. Obsidian is your reading room. They operate on the same files. One user described replacing Evernote, Notion, Asana, and Otter.ai with this combination alone.

Craft.do + MCP: capture from anywhere

Craft.do supports MCP (Model Context Protocol) — the open standard from Anthropic that acts as a standardized connector between AI tools and external data sources. Think USB-C for AI applications.

With Craft’s MCP connection, Claude Desktop or Claude Code can read and write to your Craft workspace directly. No copy-paste, no export. You are mid-conversation with Claude, a useful insight surfaces, and you tell it to save that knowledge to Craft. Done.

Setting it up in Claude Code:

claude mcp add craft --transport sse \
  https://mcp.craft.do/YOUR_MCP_URL

# Shared with team via .mcp.json
claude mcp add craft --transport sse --scope project \
  https://mcp.craft.do/YOUR_MCP_URL

# Available across all your projects
claude mcp add craft --transport sse --scope user \
  https://mcp.craft.do/YOUR_MCP_URL

# This project only, private
claude mcp add craft --transport sse --scope local \
  https://mcp.craft.do/YOUR_MCP_URL

Once connected, Claude can search, create, and update your Craft documents with folder, tag, and date filtering. The Craft MCP documentation covers the full capabilities.

The real workflow: during any Claude conversation — debugging, research, planning — you can instruct it to extract key findings and format them as a Zettelkasten-style note in Craft. The agent handles the formatting: one idea per note, proper links, frontmatter, tags. You keep thinking. It keeps filing.

Using MCP agents for Zettelkasten formatting

The Zettelkasten method — write permanent notes restating ideas in your own words, one idea per note, link related notes manually — produces high-quality knowledge bases. It also takes a lot of manual effort. The linking, tagging, and formatting are exactly the kind of tedious work that AI handles well.

With Claude Code operating on your Git-based vault, you can build a workflow where:

1. You capture raw notes, highlights, or bullet points into an inbox folder
2. Claude Code processes each item into a permanent note — rewritten in your voice, tagged, linked to related existing notes
3. It updates relevant Maps of Content (MOCs) — index notes that group related ideas by theme
4. Everything commits to Git with a meaningful diff

The key is giving the agent a consistent note template. I use a prompt that enforces this structure for every permanent note:

---
tags: [topic-tag, domain-tag]
created: YYYY-MM-DD
source: source if applicable
---

# Concise descriptive title

Core idea in 1-3 sentences — the atomic claim or concept.

## Context

Why this matters, when it applies, or background needed to understand it.

## Details

Supporting explanation, examples, or technical specifics.

## Related

- [[Related Concept 1]]
- [[Related Concept 2]]

The prompt enforces atomicity (one idea per note), active voice, concrete terms over abstractions, and a ~300 word ceiling per note. It also tells the agent to suggest 2-4 wiki link candidates for the Related section — connections you might not have made yourself.

# Zettelkasten Note-Crafting Agent

## Role

You are a Zettelkasten note-crafting specialist. You transform raw input (files, chat messages, or existing notes) into atomic, well-structured permanent notes following Zettelkasten principles and technical writing best practices.

## Input Types

You accept:
- **Files**: Course notes, articles, documentation
- **Chat**: User ideas, questions, concepts to capture
- **Existing notes**: Drafts to refine into proper Zettel format

## Output Format

Generate Obsidian-compatible markdown notes with this structure:

```
---
tags: [topic-tag, domain-tag]
created: {{YYYY-MM-DD}}
source: {{source if applicable}}
---

# {{Concise Descriptive Title}}

{{Core idea in 1-3 sentences — the "atomic" claim or concept}}

## Context

{{Why this matters, when it applies, or background needed to understand it}}

## Details

{{Supporting explanation, examples, or technical specifics}}

## Related

- [[Related Concept 1]]
- [[Related Concept 2]]
```

## Principles

### Atomicity
- **One idea per note** — If input contains multiple concepts, produce multiple separate notes
- Each note should be understandable in isolation
- Title should complete the sentence: "This note explains..."

### Technical Writing Standards
- Use active voice
- Lead with the conclusion, then support it
- Prefer concrete terms over abstractions
- Define acronyms on first use
- Use bullet points for lists of 3+ items
- Keep paragraphs to 3-4 sentences maximum

### Tone
- Neutral, academic register
- Third-person perspective
- State facts and relationships, not opinions
- Avoid hedging language ("might," "perhaps") unless uncertainty is genuinely relevant

### Formatting
- Use `##` for major sections, `###` sparingly for subsections
- Use **bold** for key terms being defined
- Use `code formatting` for technical identifiers, commands, or parameters
- Use blockquotes (`>`) only for direct quotations from sources

## Process

1. **Identify concepts** — Scan input for distinct ideas worth capturing
2. **Determine note boundaries** — Split multi-concept input into separate notes
3. **Extract core claim** — Distill each concept to its essential assertion
4. **Add context** — Provide minimal necessary background
5. **Suggest connections** — Propose 2-4 related concept placeholders

## Constraints

- Do not invent information not present or implied in the source
- Do not include filler phrases ("It is important to note that...")
- Do not exceed ~300 words per note unless technical depth requires it
- If source material is ambiguous, note the ambiguity explicitly

## Behavior

When receiving input, ask clarifying questions only if:
- The subject domain is ambiguous
- Multiple conflicting interpretations exist
- Critical context is missing

Otherwise, proceed directly to generating notes.

Here is what that looks like in practice. You drop in raw notes like “The account root user has full control. Never use it for production. Some tasks like closing the account can only be done by root” and the agent produces:

---
tags: [aws, iam, security]
created: 2025-06-13
source: AWS Training Notes
---

# AWS root user has exclusive privileges that require special handling

The AWS account root user possesses unrestricted access to all resources
and settings within an AWS account.

## Context

Every AWS account has exactly one root user, created automatically when
the account is opened. Unlike IAM users, the root user cannot be
restricted by policies.

## Details

Never use the root user for daily tasks. Create IAM users with
appropriate permissions instead.

Root-exclusive actions include:
- Closing the AWS account
- Changing account-level settings (name, email, root password)
- Modifying AWS Support plans
- Restoring IAM permissions during lockout scenarios

## Related

- [[IAM Users vs Root User]]
- [[AWS Security Best Practices]]
- [[Principle of Least Privilege]]

Three sentences of raw input become a structured, linked, reusable note. Multiply that across every article, video, and conversation you process, and the vault builds itself.

# AI MOC

## Core concepts
- [[large-language-models]]
- [[prompt-engineering]]
- [[retrieval-augmented-generation]]

## Tools and practice
- [[notebooklm-workflow]]
- [[claude-code-setup]]

## My insights
- [[ai-augmented-learning-reflections]]
- [[when-ai-fails-at-knowledge-work]]

Unlike folder hierarchies, a single note can appear in multiple MOCs. Your note on RAG might live in both an AI MOC and a Search Systems MOC. This mirrors how ideas actually connect — messily, across domains.

What I have learned running this system

Start with plain text. Every tool in this stack — Claude Code, Obsidian, Git, NotebookLM — works natively with markdown. That is not a coincidence. Plain text is portable, diffable, future-proof, and the ideal format for AI interaction.

Separate capture from processing. The inbox piles up. That is fine. What matters is a regular processing cadence where raw captures become structured notes. AI makes this fast enough to do weekly.

AI handles the linking, you handle the thinking. Finding connections, maintaining link integrity, consistent tagging — that is where AI excels. But the unexpected connection between two domains, the “wait, this applies to that problem too” — that still comes from you. AI surfaces candidates. You decide what matters.

Do not over-organize. If you are spending more time organizing than creating, the system is working against you. A few tags, flat folders, and AI-assisted linking beats an elaborate hierarchy you will not maintain.

Pick one piece of this stack and try it for a week. NotebookLM for your next research task. Claude Code pointed at a folder of markdown files. An MCP connection from Claude to your notes app. You do not need the whole system on day one — you need one workflow that reduces friction between learning something and being able to find it again later.