Second Brain and AI: Building Your Digital Knowledge Archive

Every day you read articles, watch tutorials, fix bugs, make architectural decisions, and learn new technologies. Where does all that knowledge go? Into your head? A notebook? Random bookmarks? If you’re honest, most of it disappears into the void and never stays with you. That’s exactly where the Second Brain concept comes in, combined with AI tools like ChatGPT and Claude that help you organize, maintain, and retrieve your knowledge intentionally.

In this article, I’ll show you how to build a complete knowledge management system using Obsidian, Notion, ChatGPT, Claude, Windsurf, and Cursor. You’ll learn the PARA and Zettelkasten methods, see concrete vault structures for developers, and walk away with a clear plan for optimizing your knowledge for work, studies, and side projects.

I’ve been using Obsidian for a few years now, and it’s been incredibly valuable during my studies and training. But honestly, I optimized it with AI way too late. Every clever system requires some initial setup, and when you’re busy learning course material, you’re not going to invest 2–5 hours in learning Obsidian, right? ;)

AI removes that initial friction, optimizes your structures from the start, and helps you quickly figure out whether the system works for you. So let’s dive in:

What Is a Second Brain?

The term Second Brain was popularized by Tiago Forte and his book Building a Second Brain.

The core idea is simple: Your biological brain excels at thinking and connecting ideas, but it’s terrible (at least mine is) at pure information storage. I’m just not wired that way, even with jokes.

So we offload storage to a digital system.

A Second Brain is more than a note-taking app. It’s a system that handles:

Capture: Centrally collect information from all sources (articles, books, meetings, code snippets, ideas)
Organize: Structure knowledge so you can find it without knowing exactly what you’re searching for
Connect: Build relationships between seemingly separate notes
Retrieve: Have the right knowledge ready at the right moment
Expand: Enrich old knowledge with new insights and keep it current

The concept itself isn’t new. German sociologist Niklas Luhmann ran an analog knowledge system with his Zettelkasten that made him one of Germany’s most productive scholars. His Zettelkasten contained over 90,000 note cards, systematically linked to each other. The principle: each note holds a single atomic idea, and each note points to related notes. His books and papers emerged from this network.

Today, you typically don’t need a physical Zettelkasten anymore, though analog cards can still be useful sometimes—like on your fridge or monitor ;)

You need a digital environment that creates links automatically, offers search capabilities, and can be extended with AI.

Why You as a Developer Need a Second Brain

As a software developer, you live in constant information overload. A new framework drops every week, you read about a new best practice every week, you solve a problem every day that you’ll need to solve again in three months because you forgot how you solved it the first time.

Here are the concrete pain points a Second Brain solves for developers:

Document architectural decisions: Six months ago you decided to use PostgreSQL instead of MongoDB. Why? If you didn’t write down the reasons, you’ll have to research them again for your next similar project. An Architecture Decision Record (ADR) in your Second Brain captures context, alternatives, and the decision itself for the future.

Reuse code snippets: You wrote a brilliant Python snippet for data cleaning. Three months later you face the same problem and can’t recall the code. Without a knowledge archive, you start from scratch. With a Second Brain, you search for “pandas data cleaning” and find your own code instantly.

Preserve onboarding knowledge: When a new team member joins, you explain how the CI/CD pipeline works, why you use certain libraries, and where the pitfalls are. If this knowledge is structured in your Second Brain, you can share it in minutes instead of explaining it over and over.

Track learning progress: You take a course on Kubernetes. Without notes, you’ve forgotten half of it in four weeks. With structured notes in your Second Brain that you review regularly and link to new projects, the knowledge stays with you long-term.

Secure meeting outcomes: How often have you learned about an important decision in a meeting, only to forget it a week later? Meeting notes with clear action items, linked to affected projects, belong in every knowledge management system.

PARA and Zettelkasten: The Two Methods That Sustain Your System

Before we dive into tools, you need to understand the two methods that underpin every good Second Brain:

PARA
Zettelkasten

You can use them separately, but their full power emerges when you combine them.

PARA: Where Information Lives

PARA is an organizational framework Tiago Forte developed. It divides your knowledge into four categories:

Projects: Things with a deadline and a clear objective. Example: “Migrate to React 19” or “Complete AWS certification”. When the project finishes, it moves to the archive.
Areas: Ongoing areas of responsibility without a deadline. Example: “Backend infrastructure”, “Code quality”, “Personal development”. Areas stay permanently active.
Resources: Reference material and reusable knowledge. Example: “Python patterns”, “Docker cheatsheets”, “API design guidelines”. Resources are your knowledge treasure chest.
Archives: Completed projects and inactive notes. Don’t throw them away—just archive them. You’ll often need them later.

PARA answers the question: “Where do I file this note?” It’s the cabinet structure of your Second Brain.

Zettelkasten: How Information Connects

Zettelkasten answers a different question: “How does this note relate to others?” The core principles:

Atomic notes: One note contains exactly one idea. No more, no less. This makes notes reusable and linkable. In practice, this is already quite challenging and requires discipline.
Your own words: Don’t copy notes verbatim—rephrase them in your own language. That’s how you ensure you’ve actually understood the content.
Bidirectional links: Each note points to related notes. When you write a note on “JWT authentication”, you link to “OAuth2”, “session management”, and “security best practices”. This is also difficult at first because you won’t see all connections immediately, or you’ll miss some. Manual refinement always feels tedious!
Maps of Content (MOCs): Higher-level notes that structure topic areas and serve as entry points. A MOC called “Backend architecture” links to all relevant notes on databases, APIs, caching, and message queues.

Combining PARA with Zettelkasten

PARA gives you structure; Zettelkasten gives you connections. Without PARA, you’re drowning in thousands of scattered notes. Without Zettelkasten, you have tidy folders but no cross-references. Together, they create a system where you find knowledge both by location and by relationship.

Here’s how it works in practice: your folder structure follows PARA. Inside the Resources folder lives your Zettelkasten. When you’re working on a project and discover something new, you write an atomic note and place it in Resources. Inside the project folder, you link to that note. When the project ends, the project folder moves to Archives, but the knowledge note stays in Resources and remains available for future projects.

A concrete example: you’re working on a “REST-API redesign” project and learn how to implement pagination using cursors instead of offsets. You write a note titled “Cursor-based Pagination” and store it in Resources. In the “REST-API redesign” project, you link to this note. A year later, you’re building a different API and searching for pagination patterns. You find the note immediately in Resources because it’s not tied to the old project.

Obsidian: The free, open-source backbone of your second brain—and my go-to choice for years

Obsidian is my personal choice for a second brain, and I recommend it to every developer who values privacy, flexibility, and future-proofing.

The core principle is simple: your notes are plain Markdown files stored locally on your machine. No cloud, no vendor lock-in, no dependency on a company’s whims.

Why does that matter? Imagine investing five years building knowledge in a proprietary app. The company raises prices, changes its API, or shuts down. Your knowledge vanishes or becomes locked away. With Obsidian, your notes are plain-text Markdown. In ten years, you can open them with any text editor.

I also use Astro for this website. Originally it was just a collection of learning modules for the AP1 and AP2 IT professional certifications (application development). Without the Markdown-first approach, none of this would exist as a website.

Getting started: installation and your first vault

Installation takes seconds:

Download Obsidian from obsidian.md (available for Windows, macOS, Linux, iOS, and Android)
Create a new vault (just a folder on your disk)
Done. Start writing notes immediately.

A vault is simply a directory full of Markdown files. You can version it with Git, sync it between devices with Syncthing, or use the paid Obsidian Sync service (4 dollars per month).

Vault structure for developers: job, side business, personal

Here’s the vault structure I use myself, adapted for a developer’s life across multiple domains:

📁 Vault/
├── 📁 00-Inbox/
├── 📁 10-Job/
│   ├── 📁 Projects/
│   │   ├── 📁 Sprint-42-Auth-Revamp/
│   │   └── 📁 API-Migration-v2/
│   ├── 📁 Areas/
│   │   ├── 📁 Backend-Infrastruktur/
│   │   ├── 📁 Code-Qualitaet/
│   │   └── 📁 Team-Onboarding/
│   ├── 📁 Resources/
│   │   ├── 📁 Python-Patterns/
│   │   ├── 📁 Docker-Cheatsheets/
│   │   ├── 📁 API-Design/
│   │   └── 📁 Debug-Logs/
│   └── 📁 Archives/
├── 📁 20-Unternehmen/
│   ├── 📁 Projects/
│   │   ├── 📁 Website-Relaunch/
│   │   └── 📁 Kunde-Mueller-App/
│   │   └── 📁 Mustertexte-Selativum-App/
│   ├── 📁 Areas/
│   │   ├── 📁 Kundenverwaltung/
│   │   ├── 📁 Angebote-und-Rechnungen/
│   │   └── 📁 Marketing/
│   ├── 📁 Resources/
│   │   ├── 📁 Vertrags-Templates/
│   │   ├── 📁 Projekt-Schablonen/
│   │   └── 📁 Steuer-und-Recht/
│   └── 📁 Archives/
├── 📁 30-Privat/
│   ├── 📁 Projects/
│   │   ├── 📁 AWS-Zertifizierung/
│   │   └── 📁 Hobby-Ryzen-Cluster/
│   ├── 📁 Areas/
│   │   ├── 📁 Weiterbildung/
│   │   ├── 📁 Buecher-und-Kurse/
│   │   └── 📁 Finanzen/
│   ├── 📁 Resources/
│   │   ├── 📁 Lernnotizen/
│   │   ├── 📁 Buchzusammenfassungen/
│   │   └── 📁 Tools-und-Tricks/
│   └── 📁 Archives/
└── 📁 Templates/

The 00-Inbox folder is your most important one. Everything you want to capture quickly goes here, without deciding where it belongs. Articles, links, ideas, code snippets—everything lands in the inbox first, then gets sorted during your weekly review. The inbox isn’t storage; it’s a queue.

Backlinks, graph view, and bidirectional connections

Obsidian’s superpower is bidirectional linking. When you type [[JWT-Authentifizierung]] in a note, Obsidian automatically creates a backlink. Open the “JWT-Authentifizierung” note, and you’ll see at the bottom every note linking to it. Of course, you have to discipline yourself to actually create those links.

The payoff: you don’t need to remember where you stored something. Just type [[concept]] and Obsidian connects it automatically. The graph view shows you visually how your notes relate to each other. Isolated notes with no connections stick out immediately—a signal that you should either integrate them with your knowledge base or delete them.

Practical example: Obsidian in action

You write a note about “Connection Pooling in PostgreSQL” and link to [[PostgreSQL]], [[Performance-Optimierung]], and [[Backend-Infrastruktur]].

Later, when you open “Performance-Optimierung”, the backlink section shows you that connection pooling note—something you might have otherwise forgotten existed.

Templates: ADRs, debug logs, code snippets, meeting notes

Templates are how you keep notes consistent. In Obsidian, you create templates as Markdown files in the Templates folder and use either the built-in Templates core plugin or the community plugin Templater.

Example: Architecture Decision Record template in Obsidian

Architecture Decision Record (ADR) Template:

# ADR: {{title}}

Date: {{date}}
Status: Proposed
Decision makers: 

## Context
What problem are we solving? What context leads to this decision?

## Alternatives
- Option A: ...
- Option B: ...
- Option C: ...

## Decision
Chosen: Option X

## Rationale
Why this option? What criteria were decisive?

## Consequences
What changes? What risks exist?

## Links
- [[Projekt-Name]]
- [[Verwandte-ADR]]

Debug Log Template:

# Debug: {{title}}

Date: {{date}}
Environment: 
Component: 

## Symptom
What's the problem? What error message appears?

## Reproduction
1. Step 1
2. Step 2
3. Step 3

## Investigation
What did you try? What didn't work?

## Solution
What worked? Why?

## Links
- [[Related-Bug]]
- [[Component]]

Critical point: write the debug log while you’re investigating, not after you’ve fixed the bug. During troubleshooting, you have 80 percent of the context in your head. Once the bug is fixed, that context evaporates quickly.

Example: Code snippet template in Obsidian

Code Snippet Template:

# {{title}}

Tags: #python #pandas

What does this code do?

A plain-language explanation.

Code

# Your code here

When to use it

Concrete scenarios where this snippet comes in handy.

Gotchas

What pitfalls should you watch out for? What needs careful attention?

Source

Where did this code come from? Stack Overflow, docs, a colleague?


I rely on this template structure constantly—especially when I'm working with a programming language I rarely touch. It's equally valuable during the learning process. There's always a reason you pick a list, a map, or something else over alternatives.

The "When to use it" field is the critical one. If you can't explain in a single sentence when you'd need this snippet, you don't understand it well enough to keep it around.

### Attachments and images: Keeping your vault organized

Text works fine, but images often communicate faster. Sometimes you need to embed screenshots, diagrams, or PDFs into your notes. Astro.build's approach to handling images bugged me for a while, and Obsidian had the same problem out of the box.

The default behavior: you drag an image into a note, and it lands in your vault root. Three months later, you've got 200 images in your main directory. Total mess.

**The fix: configure your attachments folder.**

Go to Settings → Files and Links → Default location for new attachments → "In the folder specified below". Set a folder like `99-Attachments/`. From then on, all images land there automatically.

**My recommendation: use a subfolder structure.** Try `99-Attachments/Screenshots/`, `99-Attachments/Diagrams/`, `99-Attachments/PDFs/`. Or grab the "Custom Attachment Location" plugin to organize subfolders per note.

**What's worth knowing:**
- Images are plain files (PNG, JPG, SVG) and sync like any markdown
- PDFs open directly in Obsidian and are searchable
- Code as a screenshot is convenient but not searchable. Better: paste it as a code block
- Deleted images show up as broken links in your notes

### Dataview: Dynamic queries over your notes

The Dataview plugin ranks among Obsidian's most powerful tools. It lets you query your notes like a database. You can generate tables, lists, and calendars that update automatically.

Here are three Dataview queries I use daily:

**Open ADRs waiting for review:**

```dataview
TABLE status, date AS "Date" FROM "10-Job/Areas"
WHERE contains(file.name, "ADR") AND status != "Accepted" AND status != "Superseded"
SORT date DESC

Debug logs from the last 14 days:

TABLE file.mtime AS "Date" FROM "10-Job/Projects"
WHERE contains(file.name, "Debug")
WHERE date(file.mtime) > date(today) - dur(14 days)
SORT file.mtime DESC

Notes with a specific tag:

LIST FROM #docker AND #cheatsheet
SORT file.mtime DESC
LIMIT 10

Set these queries up once on your homepage or in an index note, and they stay current without any manual maintenance.

Smart Connections: AI-powered note suggestions, locally

As your vault grows, keeping all those notes in your head gets harder. The Smart Connections community plugin solves this. It analyzes your notes semantically and shows you related notes in the sidebar whenever you open something.

The key feature: Smart Connections runs entirely locally. It uses local embedding models, which means none of your notes leave your machine. For developers handling sensitive project data, that’s a huge win.

Installation: Settings → Community Plugins → search “Smart Connections” → Install → Enable. After the initial indexing (takes a few minutes depending on vault size), you’ll see related notes in your sidebar. Open a note about “Docker Compose Networks” and Smart Connections pulls up your notes on “Kubernetes Networking”, “Bridge vs Host Mode”, and “Port Mapping”—stuff you wrote months ago and forgot about.

Obsidian Copilot: Chat with your vault

The Copilot plugin brings ChatGPT-style functionality straight into Obsidian. You ask your vault questions and get answers based on your own notes.

Example queries I use regularly:

“Summarize all my notes about PostgreSQL performance”
“What architecture decisions did we make last quarter?”
“Do I already have a note on Redis caching strategies?”

You can pick between different models: OpenAI’s GPT, Anthropic’s Claude, or local models via Ollama. If privacy matters to you, use Ollama with a local Llama or Mistral model. Your notes stay on your machine, the AI runs locally.

Daily Notes: Done right

Daily Notes annoyed me for a long time. I’d end up with 200 daily notes, 180 of them useless. The problem isn’t the concept—it’s how people use it.

Daily Notes aren’t a diary. They’re a temporary workspace for the day. A place for tasks and quick thoughts, not reflection.

My minimal template:

# {{date}}

## Today
- [ ] 

## Inbox
-

No gratitude list, no reflection prompts. If you’re filling out 10 fields every day, you’ll stick with it for three days, then never again.

Tips for the undisciplined (like me):

Don’t write every day. Sunday on the couch? Skip it. Create notes manually, disable auto-creation.
The inbox section is the most important field. Dump everything there, sort it at the end of the day.
Link generously. Type “Meeting about [[API-Redesign]]” and you instantly create a backlink.
Don’t delete old notes. They’re a timeline for performance reviews.
Use the Calendar plugin for navigation. Click a day in the calendar, open the note.

The honest truth: If you lack discipline, use Daily Notes as pure inbox. Don’t write anything in the morning unless you want to. Treat them as a catch-all for the day. Whatever lands there gets sorted during your evening or Monday weekly review. The daily note itself then just becomes a task history.

Canvas and Excalidraw: Visual thinking for architecture

Sometimes text alone doesn’t cut it. When you’re sketching architecture, planning a data flow, or visualizing dependencies, you need a visual layer. Obsidian gives you two options:

Obsidian Canvas is the built-in whiteboard tool. You arrange notes, images, text, and links as cards on an infinite surface and connect them with arrows. The magic: you can lay out your existing notes visually without duplicating them. A Canvas called “Microservice Architecture” holds cards linked to your notes about API gateways, message queues, and databases, connected with arrows showing data flow.

Canvas files are JSON files living locally in your vault. They sync like any other file. You can export and share them.

Excalidraw is a community plugin that embeds the open-source drawing app of the same name into Obsidian. It’s perfect for hand-drawn sketches, diagrams, and wireframes. Unlike Canvas, which uses structured cards, Excalidraw is freeform. You draw what you want and embed it in your notes.

My workflow: Canvas for architecture overviews where I link existing notes. Excalidraw for quick sketches when I want to visualize a UI concept or algorithm. Both file types live in the vault and connect to your text notes through backlinks.

Notion: When structure and collaboration matter

Obsidian is my personal favourite, but Notion earns its place. If you work in a team, need structured databases, or prefer a gentler learning curve, Notion is the better choice.

Databases and views: Structured knowledge

Notion’s strength lies in its databases. You can create tables, Kanban boards, calendars, galleries, and timelines from the same dataset. Here’s a concrete example: you have a database of books you want to read. In table view, you see every book with author, reading status, and rating. Switch to Kanban view and organize them by progress. Gallery view shows you the book covers.

For developers, this is valuable for bug tracking, learning roadmaps, project documentation, and customer management.

Notion AI: Write, summarize, ask questions

Notion AI integrates deeply into the editor. Select text and ask the AI to summarize, rewrite, or expand it. You can ask questions about your entire workspace.

Real-world example: you have 20 meeting notes from the last quarter. You ask Notion AI: “Which action items from meetings in the past three weeks are still open?” Notion AI searches all your notes and presents you with a filtered list.

Notion AI Connectors: Slack, GitHub, Google Drive integration

As of 2025, Notion AI offers Connectors. You can integrate external tools like Slack, GitHub, Google Drive, Jira, and Gmail. Notion AI then searches not just your workspace but also these external sources.

For developers, particularly useful: GitHub Connector for open issues, Slack Connector for decisions from channels, Google Drive Connector for documents.

Trade-offs with Obsidian

Criterion	Notion	Obsidian
Privacy	Cloud-based	Local
Format	Proprietary	Markdown
Collaboration	First-class	Limited
Databases	Strong	Via Dataview plugin
Plugins	Limited	2700+ community plugins
Price	Free to $10/month	Free; Sync $4
Offline	Limited	Full
AI	Built-in (cloud)	Via plugins (local possible)

My recommendation: use Obsidian for your personal knowledge archive and Notion for team documentation and collaborative projects. Both tools complement each other rather than compete.

Free open-source alternatives for your second brain

Obsidian is free but not open source. If you value truly open-source software, you have options:

Logseq: Similar to Obsidian, it’s built on local Markdown files. The difference: Logseq is outliner-based, where every note is a hierarchical list. Everything is structured as bullet points. This suits some thinking styles perfectly; others find it restrictive. Logseq is open source and free. The graph view and backlinks are about as powerful as Obsidian’s. AI integration is still in development, but community plugins already exist.

Joplin: A straightforward note client with solid Markdown support. I began my Markdown journey with Joplin and found the switch to Obsidian difficult because I was already satisfied with it. That said, Obsidian had a strong reputation even then, so I ran both for a while. It has fewer plugins than Obsidian but feels more stable and simpler. Good for beginners who don’t want to build a complex vault immediately. Joplin is open source and offers solid sync functionality with multiple backends (Nextcloud, Dropbox, WebDAV).

AppFlowy: An open-source alternative to Notion. It offers similar database functions and views, but locally and free. Not as mature as Notion yet, but actively developed. Worth exploring if you want Notion-like structure without moving to the cloud.

Heptabase: A visual tool that combines whiteboards with Markdown notes. You arrange and connect notes like cards on a whiteboard. Ideal for visual thinkers and project planning. Heptabase isn’t open source, but it’s local-first and has a free tier.

My recommendation: if open source is a requirement, start with Logseq. It’s the most mature Obsidian alternative in the open-source space.

ChatGPT and Claude: AI as your thinking partner

Your second brain stores knowledge. ChatGPT and Claude help you refine that knowledge, expand it, and discover new connections.

Refining notes with Claude: Summarize, restructure, expand

Claude excels at structuring long texts. If you have messy notes from a meeting, paste them into Claude and ask for structure.

Example prompt for Claude:

Here are my raw meeting notes. Please structure them 
into these sections: Summary, Decisions, 
Action Items (with owners), Open Questions. 
Keep all technical details intact.

[Your notes here]

Claude returns a clean, well-organized note you can drop directly into Obsidian.

Another example: you have five different notes on “Docker Networking” from various projects. Give Claude all five and ask for a consolidated resource note. Claude identifies duplicates and creates a note covering all aspects.

ChatGPT for knowledge gaps: Ask, verify sources

ChatGPT is your quick research assistant. When you discover a gap in your knowledge, ask ChatGPT and use the answer as a starting point for a new note.

Important: treat ChatGPT as a starting point, not an endpoint. Verify critical information against official documentation.

Workflow:

You discover a knowledge gap
You ask ChatGPT and get an explanation
You verify key points against official docs
You write an atomic note in your own words
You link it to related topics in your vault

RAG (Retrieval Augmented Generation) with your notes

RAG means feeding a model your own notes as context before asking a question. With Obsidian Copilot, this happens automatically. Without a plugin, you do it manually: find relevant notes, paste them into ChatGPT or Claude, ask your question with reference to those notes.

Example prompt:

Based on these notes from my knowledge archive: 
Which API design patterns have I already documented, 
and which are still missing compared to common best practices?

[Your notes here]

The AI compares your knowledge against best practices and shows you the gaps you can then fill with new notes.

Best prompts for a solid vault structure

Good structure matters most. At first, you don’t know how to organize. Later, you lose the overview. Here are prompts for both situations.

Planning a vault from scratch:

I want to create an Obsidian vault for these areas:
[Your areas, e.g., Job, Freelance, Personal]

Suggest a PARA-compatible folder structure:
- Maximum 3 levels deep
- Every note has a clear home
- Inbox folder for quick capture
Give me the structure as a tree diagram.

Auditing an existing vault:

Here is my current vault structure:
[Folder structure as a list]

Analyze:
1. Any folders that violate PARA?
2. Duplicate or overlapping folders?
3. Which folders are too large (>50 notes)?
4. Which ones are never used?
Suggest specific improvements.

Finding connections:

Here are all my note titles:
[Titles as a list, one per line]

Find notes that belong together thematically 
but sound different in their titles.
Suggest links: [[Note A]] <-> [[Note B]] (reason)

Simplifying your tag system:

I currently use these tags: [Your tags as a list]
Problem: Too many, inconsistent.
Suggest max 15 tags for:
- Topics (docker, python, api)
- Note types (adr, debug, snippet, meeting)
- Status (draft, review, archived)

Finding lost notes:

I'm looking for a note about [topic].
Here are all my note titles:
[Titles as a list]

Which ones might contain this topic?

Tip: Use Obsidian Copilot or Smart Connections to run these queries directly in your vault. For large vaults, manually copying all titles is tedious. With MCP, you can let Cascade or Cursor access your vault directly.

Windsurf.ai and Cursor: Your Second Brain in the Editor

As a developer, you spend most of your time in the editor. Wouldn’t it be ideal to have your second brain available directly inside the editor? That’s exactly what Windsurf.ai and Cursor offer through MCP and Memory Bank concepts.

What is an MCP Server?

MCP stands for Model Context Protocol. It’s an open standard released by Anthropic, the creators of Claude. The problem MCP solves: AI assistants like Windsurf, Cursor, or Claude Desktop operate in isolation. They can read your code, but not your Obsidian notes, Notion pages, or GitHub Issues. MCP creates a unified interface that allows AI clients to access external tools.

An MCP Server is a small program that acts as a bridge between an AI client and an external data source. For example: the Obsidian MCP Server reads your vault files and makes them available to the AI. The Notion MCP Server accesses your databases via the Notion API. The GitHub MCP Server reads issues and pull requests.

The AI in your editor asks the MCP Server: “Do you have any notes about Redis caching?” The server searches the vault and returns the results. The AI then uses that information to give you a well-informed answer based on your own knowledge.

Memory Bank: Preserve Project Knowledge Across Sessions

Windsurf and Cursor share a common limitation: after each new session, the AI “forgets” what was discussed in previous conversations. The solution is a Memory Bank—a directory in your project that the AI reads at the start of each session.

A typical Memory Bank structure looks like this:

memory-bank/
├── projectbrief.md      # Project description and goals
├── productContext.md    # Why does this project exist?
├── activeContext.md     # Current work, next steps
├── systemPatterns.md    # Architecture and patterns
├── techContext.md       # Technologies, setup, dependencies
└── progress.md          # Status and milestones

In Windsurf, you create a .windsurfrules file in the project root that instructs Cascade to read these files. In Cursor, it works similarly with .cursorrules.

MCP (Model Context Protocol): Connect Obsidian and Notion to Your Editor

MCP is the standard that enables AI assistants to access external tools. With MCP, you can integrate Obsidian or Notion directly into Windsurf or Cursor.

Setting up Obsidian MCP in Windsurf:

In your Windsurf MCP configuration (~/.codeium/windsurf/mcp_config.json):

{
  "mcpServers": {
    "obsidian": {
      "command": "npx",
      "args": ["-y", "obsidian-mcp-server"],
      "env": {
        "OBSIDIAN_VAULT_PATH": "/path/to/your/vault"
      }
    }
  }
}

After restarting Windsurf, Cascade can search, read, and create notes in your Obsidian vault. You ask Cascade: “Do I have any notes about Redis caching strategies?” and Cascade searches your vault without you needing to open Obsidian.

Setting up Notion MCP in Cursor:

{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": ["-y", "@notionhq/notion-mcp-server"],
      "env": {
        "NOTION_API_KEY": "your-api-key"
      }
    }
  }
}

Now Cursor’s AI can access your Notion pages and databases.

.windsurfrules and .cursorrules: Static Project Instructions

Beyond MCP, both editors support static rule files. These are read automatically at the start of each session and work best for project-specific knowledge that rarely changes.

Example of a .windsurfrules file:

Project: E-Commerce Backend
Stack: Python 3.12, FastAPI, PostgreSQL, Redis
Architecture: Microservices, Event-Driven

Conventions:
- Use SQLAlchemy 2.0 Style
- All endpoints require OpenAPI documentation
- Test with pytest, minimum 80% coverage
- See also: [[ADR-001-CQRS-Pattern]]

Related notes from Obsidian:
- [[PostgreSQL-Connection-Pooling]]
- [[Redis-Caching-Strategies]]
- [[FastAPI-Best-Practices]]

The difference from the Memory Bank: .windsurfrules is static and maintained by hand. The Memory Bank is updated by the AI itself. Use both together: .windsurfrules for fixed rules, Memory Bank for dynamic project progress.

Real-World Example: Using Architecture Decisions from Obsidian in Windsurf

Imagine you’re working on a new feature in Windsurf and need to make an architecture decision. Without integration, you’d have to open Obsidian, search for the relevant ADR, copy the content, and paste it into Windsurf.

With MCP integration, you simply ask Cascade: “Read my ADRs about authentication and propose an approach for this feature.” Cascade searches your vault, finds the relevant ADRs, and proposes an approach that’s consistent with your previous decisions.

That’s the real benefit: your second brain isn’t just passively stored—it’s actively woven into your development workflow.

Workflows for Three Life Areas

I use my second brain in three contexts. Each has different requirements and routines.

Work: Architecture Decisions, Debug Logs, Onboarding Knowledge

In 10-Job/, I focus on reproducible knowledge for daily work.

Daily: Everything goes into 00-Inbox/. When debugging, I fill in a debug log before looking for the solution. When making architecture decisions, I write an ADR.

Weekly (Monday mornings, 20 minutes): Empty the inbox, review open ADRs, scan debug logs, and extract key insights into Resources.

Monthly: Archive completed projects, find orphaned notes in Graph View, and update MOCs.

Small Business: Client Notes, Quotes, Project Management

In 20-Kleinunternehmen/ (Small Business), I organize my freelance work.

Each client gets a folder under Areas/Kundenverwaltung/ (Client Management) with contact info, project status, and billing history. Under Resources/Projekt-Schablonen/ (Project Templates), I keep templates for quotes and contracts. Active projects live under Projects/ with their goal, scope, and timeline.

Example: Client Mueller wants a web app. I create Projects/Kunde-Mueller-Web-App/ with a project note, link to [[React-Best-Practices]] and [[Vertrags-Template-Festpreis]] from Resources. Once the project is done, it moves to the archive, but the patterns I learned stay in Resources.

Private: Learning Projects, Books, Online Courses, Hobby Coding

In 30-Privat/, I collect everything related to personal development.

Learning Projects: A Kubernetes course is a Project. While taking the course, I write rough notes in the project folder. When I want to keep a insight permanently, I extract it as an atomic note in Resources/Lernnotizen/. I link it with [[Docker-Grundlagen]] and [[Container-Orchestrierung]].

Books: Under Resources/Buchzusammenfassungen/ (Book Summaries), I keep my book notes. Each book gets a note with key takeaways, important quotes, and my personal insights, linked with related topics.

Hobby Coding: My RasPi Cluster project lives under Projects/Hobby-RasPi-Cluster/. Debug logs, setup notes, and configuration snippets are collected here and connected with Resources.

Daily and Weekly Routines

A Second Brain only works with consistent maintenance.

Daily Review (5 min, mornings): Open your Daily Note, add tasks, scan your inbox.

Weekly Inbox Processing (20 min, Mondays): Sort every inbox note into its proper place, link it, or delete it. Your inbox is a queue, not storage.

Monthly Review (30 min): Archive completed projects, scan Graph View for isolated notes, update your MOCs.

Learning with Your Second Brain: For Studies, Professional Development, and Certifications

A Second Brain is particularly valuable for learning. Whether you’re studying for a degree, pursuing a certification, or mastering new technologies, the right note-taking techniques make the difference between “read and forgotten” and “understood and retained.”

Spaced Repetition with Obsidian

Spaced Repetition is the scientifically proven learning method for storing knowledge durably. The Obsidian plugin “Spaced Repetition” integrates this technique directly into your vault.

You mark important notes as flashcards (using the #flashcards tag), and the plugin tests you at properly spaced intervals. A card you answer correctly reappears after a longer interval. One you get wrong comes back the next day.

For example: you’re preparing for the AWS Solutions Architect certification. You write atomic notes on S3 Storage Classes, VPC Architecture, and IAM Policies. Each note gets the #flashcards tag. After four weeks, the core concepts are permanently stored in your memory.

The Feynman Technique in Your Notes

You truly understand a topic only when you can explain it simply enough for a beginner to follow. After each learning session, write a note titled “Explanation for Beginners: [Topic]”. If you get stuck, you’ve found a knowledge gap.

Active Recall with Obsidian

Active Recall means you retrieve knowledge from memory rather than passively reading. Write a note with a question as the title (for example, “How does the TLS handshake work?”) and the answer in the body. When reviewing, open only the title, try to reconstruct the answer from memory, then compare it with your note.

Common Mistakes and How to Avoid Them

Note Hoarding: You save articles, links, and code snippets without ever processing them. Your vault becomes a digital graveyard. Solution: process every note during your weekly inbox review. If you haven’t read a note after three weeks, delete it.

No Linking: You write notes but never connect them to others. Your vault becomes isolated islands. Solution: before you close a note, ask yourself: “Is there an existing note related to this?” If yes, link it with [[Note-Title]].

Too Many Tools: You use Obsidian, Notion, Evernote, OneNote, and Apple Notes simultaneously. Your knowledge is scattered across five tools. Solution: pick one primary tool (my recommendation: Obsidian) and use others only for specific purposes (Notion for team collaboration).

No Inbox Processing: You dump everything into your inbox and never sort it. The inbox becomes a graveyard. Solution: schedule your weekly review as a fixed calendar event. Twenty minutes, every Monday.

Overly Complex Structure: You build a folder system with ten levels and 50 tags. You spend more time organizing than writing notes. Solution: start simple. PARA with four folders is enough. Use tags only for cross-cutting topics, not for every note.

Save Everything, Delete Nothing: You’re afraid of losing information. Solution: trust your archive. Notes you never need again can be deleted.

The Tool Proliferation Trap: When You Use Five Tools for the Same Job

I use Obsidian for notes, Vikunja for project management, ClickUp for task management, and Notion for team documentation. You probably have similar combinations: multiple tools with overlapping purposes. The problem: you spend more time deciding where to write something than actually writing it. And at the end, you don’t remember whether that important info is in Obsidian, Vikunja, or ClickUp.

The hard truth: eventually you must decide. One primary tool for notes, one for tasks, one for team collaboration. You don’t need more than that.

But here’s the thing: only those who actually try it properly will figure out their best approach. Try Obsidian as your primary tool for 30 days. Not in parallel with Evernote, not as a “trial on the side.” Really commit. If it doesn’t work after 30 days, try Notion. But don’t run five tools at once. That’s not a Second Brain—that’s Second Chaos.

Why AI Can’t Help You Choose the Right Tool

One thing AI has never helped me with is finding a better product than Obsidian or Notion. When you ask ChatGPT or Claude, “What are alternatives to Obsidian?”, you get a list. Capacities, Anytype, Reflect, Mem, Supernotes, Heptabase, RemNote. The list is always similar.

The problem: when you try these tools, critical features are often missing. No backlinks like Obsidian. No 2700 community plugins. No local Markdown storage. No Dataview queries. It feels inferior. Nice UI, but under the hood it lacks what makes Obsidian strong.

AI knows the tools, but it doesn’t know your workflow. It doesn’t know you need Dataview queries, that you insist on local files, that your vault has 5000 notes and Graph View is essential for you. It recommends based on popularity and marketing, not on your actual requirements.

My experience after countless tool tests: there’s currently no tool that beats Obsidian in the combination of local storage, plugin ecosystem, Markdown storage, and AI integration. Notion is strong for teams, but for a solo developer with data privacy concerns, Obsidian has no competition. Stop searching and start using.

Real-World Mistakes

The theoretical mistakes above—maybe everyone knows them. Here are mistakes I’ve made myself that cost me real time and stress.

Checklists and Todo-Lists in Every Folder

I’d built a checklist and todo-list with extensions in every folder. For every project, every area, every resource directory. The idea was good, but the reality was that I got overwhelmed by notifications.

Obsidian displays open tasks across all notes. If you maintain a todo-list in 20 folders, you’ll soon have 200 open tasks. Your Daily Note becomes unusable. Especially when you build checklists for IT work, complexity explodes: a “Server Setup” checklist has 40 items, a “Code Review” checklist has 25, a “Deployment” checklist has 30. Multiply that by your projects and you’re facing a wall of tasks that paralyzes rather than motivates you.

What I learned:

Keep tasks in only two places: your Daily Note (for today) and within the relevant project folder. Not in Areas or Resources.
Store checklists as templates in your Templates folder, not as active todo-lists everywhere.
Use the Tasks plugin query deliberately: filter not done only for your current project folder, not globally.
If a task hasn’t been touched in 7 days, it doesn’t belong in your Daily Note.

Too Many Plugins Too Soon

30 plugins in the first week. Obsidian felt sluggish, the interface cluttered, nothing properly configured. The real game-changer—precisely because it’s so simple yet feels wrong at the start—is this: less is more. Start with five plugins: Dataview, Templater, Tasks, Calendar, Smart Connections. Add the rest when you actually need them.

Vault Without Backup

A local vault without backup is a single point of failure. Hard drives fail.

Solution: Git with a private repository. A git push at the end of each day backs everything up.

Multiple Vaults: Keeping Work and Personal Separate

This was genuinely a problem for me. I wanted to sync only parts of my vault to my work machine. The disappointment: either you maintain two vaults or you encrypt certain notes.

Option 1: Two separate vaults — Clean separation, zero risk of personal notes leaking to your work machine. Downside: no links between work knowledge and personal insights.

Option 2: One vault with encrypted folders — The “Meld Encrypt” plugin lets you encrypt folders with AES-256. Downside: encrypted notes aren’t searchable, and Dataview and Smart Connections won’t index them.

Option 3: One vault with selective sync — Obsidian Sync supports “Excluded Folders”: 30-Privat/ won’t sync to your work machine. Downside: only available with Obsidian Sync ($4/month).

My recommendation: Strict separation (compliance requirements) = Option 1. Flexibility = Option 3.

Practical Tip: Work Machine and Network Drive Documentation

Here’s a situation many developers face: you want to sync your personal notes on your work machine, but simultaneously write company documentation on the network drive. Two worlds that shouldn’t mix.

The temptation: mount the network drive as a folder in your vault. Then you’ve got everything in Obsidian. But watch out: the network drive belongs to the company. Your personal notes now sit in the same vault as company data. That creates compliance headaches and is tough to explain during an audit.

My strategy: two vaults with separate sync paths.

Vault 1: Personal vault (e.g., ~/Documents/MyBrain/)

Syncs via self-hosted LiveSync or Obsidian Sync
Contains 10-Job/, 20-Unternehmen/, 30-Privat/
The 10-Job/ folder holds your personal work notes: ADRs, debug logs, learning notes
These are your private records, not official company documentation

Vault 2: Company documentation vault (e.g., on the network drive Z:\Dokumentation\)

Lives directly on the network drive, backed up by your company
Contains official documentation: API docs, setup guides, ADRs the team sees
No sync needed; the network drive handles that

The workflow: you write notes first in your personal vault. When something’s relevant to the team, you copy it into the company vault and adapt it (strip personal notes, make it team-friendly). It sounds like extra work, but it has a big advantage: your personal vault captures your unfiltered thoughts and discoveries. The company vault contains polished, reviewed documentation.

Why not put a network folder inside one vault?

Your company has access to the network drive. Your personal notes shouldn’t be there.
Obsidian creates .obsidian/ configuration directories in your vault. These would be visible to everyone on the network drive.
Sync tools (Git, LiveSync) would try to sync company data. You don’t want that.
Switching vaults in Obsidian is two clicks. No friction.

Lazy alternative: if you really want just one vault, use Option 3 (selective sync) and create a 10-Job/Firmen-Doku/ folder you manually copy to the network drive. But that requires discipline and is error-prone. Two vaults are cleaner.

The Best Way to Sync

Obsidian Sync ($4/month): end-to-end with AES-256-GCM. Not even the Obsidian team can read your notes. Audited by Cure53 and Trail of Bits. Selective sync to exclude folders. Versioning built in.

Self-hosted LiveSync with Coolify (free): CouchDB backend, deployable via Coolify one-click template. E2E with AES-256-GCM; the server stores only ciphertext. Live sync over WebSockets. Setup URI for easy device onboarding.

Nextcloud Sync (free): uses Nextcloud’s APIs with checksums, file locking, and versioning. Encryption over HTTPS at transport layer. With Nextcloud E2EE enabled, files are encrypted at rest. Good if you’re already running Nextcloud.

Git (free): private repository, git push at day’s end. Full version history, no live sync. Use git-crypt to encrypt specific files.

Syncthing (free, peer-to-peer): syncs directly between devices over TLS, no cloud needed. No versioning, no selective sync.

How encrypted are the data?

Obsidian Sync: AES-256-GCM, E2E, key derived with scrypt
Self-hosted LiveSync: AES-256-GCM, E2E, passphrase never leaves your device
Nextcloud: HTTPS transport, optional E2EE via Nextcloud itself
Git: unencrypted, git-crypt for individual files
Syncthing: TLS transport, no at-rest encryption

My recommendation: if you have a server with Coolify like I do: self-hosted LiveSync. Free, E2E, you control your data. If you don’t have a server: Obsidian Sync for convenience or Git for a developer workflow.

Mobile Use: Your Second Brain on the Go

Obsidian is free on iOS and Android. That means your entire vault is available on your phone. But mobile use is different from desktop.

Quick capture is everything. On your phone you don’t want to write long notes. You want to capture something fast and sort it out later at your desk. Three ways to do it:

Obsidian directly: open the app, tap ”+”, and write a note into 00-Inbox/. Fast, but you need to open the app.
Share Sheet: on iOS and Android you can use Obsidian as a share target. Reading an article in your browser? Share it to Obsidian, and the link becomes a new inbox note.
Shortcut/Automate: on iOS use Shortcuts to create a new inbox note with one tap. On Android try Automate or Tasker.

What works well on mobile:

Capturing to your inbox (links, ideas, quick notes)
Reading and searching notes
Checking off tasks in your daily note
Following backlinks and browsing related notes

What doesn’t work well on mobile:

Writing long notes (keyboard is too small)
Creating Dataview queries
Filling out templates
Editing Canvas or Excalidraw

Sync for mobile: with Obsidian Sync it works out of the box. Self-hosted LiveSync also works—just enter the setup URI. Git is more involved (Git client on your phone, manual pull/push). Syncthing works but runs as a background service, which drains your battery.

My recommendation for mobile: use your phone for capture only. Save all organizing and structuring for your desktop.

Quick-Start Checklist: Build Your Second Brain in 30 Minutes

Don’t want to read the whole article before getting started? Here’s the checklist:

Tool Overview: Which Tool for What?

Tool	Open Source	AI	Strengths	Price
Obsidian	No	Via plugins	Plugins, privacy, graph	Free
Notion	No	Built-in	Databases, collaboration	up to $10
Logseq	Yes	In development	Outliner, open source	Free
Joplin	Yes	No	Simplicity, sync	Free
AppFlowy	Yes	No	Local Notion alternative	Free
Heptabase	No	No	Visual thinking	Free (tier)

Combinations that work:

Solo developer: Obsidian + ChatGPT/Claude + Windsurf with MCP
Team: Obsidian (personal) + Notion (team) + Cursor with MCP
Open-source enthusiast: Logseq + Ollama + Git Sync
Visual thinker: Obsidian + Heptabase + Excalidraw

The Best Obsidian Plugins

Obsidian has over 2,700 community plugins. A blessing and a curse. Over time, I’ve installed, uninstalled, and reinstalled countless ones. Here’s my honest list: plugins I actually use, and plugins I installed but barely touch.

Core plugins (built-in, just enable them):

Templates - Templates for recurring note types. Foundation for consistent notes.
Daily Notes - Daily notes. Enable it, but turn off auto-creation (see the Daily Notes section).
Backlinks - Bidirectional links. The heart of Obsidian.
Graph View - Visual map of how your notes connect. Isolated notes stand out immediately.
Canvas - Whiteboard for visual architecture sketches. Built-in, no community plugin needed.
Search - Full-text search across your entire vault.

Community plugins I use every day:

Tasks - Task management with due dates, recurring tasks, and queries. A game-changer for todo lists in Obsidian. You write - [ ] Task due 2025-01-15 and the plugin tracks it.
Reminder - Notifications for tasks and notes. Pop-up at the scheduled time. Simple, but essential because I forget tasks otherwise.
Dataview - Dynamic queries over your vault. Like SQL for Markdown files.
Templater - Templates on steroids. Dynamic variables, JavaScript snippets, automatic date formatting. If you’re serious about templates, Templater beats the core plugin.
Calendar - Calendar view for Daily Notes. Click a day, open the note. Faster than searching.
Git - Version control for your vault. Auto-commit and push at day’s end. Backup without the cloud.

Installed but rarely used (honest truth):

These plugins sounded great when I installed them, but I rarely or never use them. That’s not a knock on the plugins—it’s on my habits:

Better Export PDF - PDF export with better formatting. Hardly need it since I read notes in Obsidian, not as PDFs.
Diagrams - Create diagrams directly in Obsidian. I prefer Excalidraw for this.
Digital Garden - Publish your vault as a website. Nice experiment, but not my workflow.
Editing Toolbar - Toolbar for Markdown formatting. I prefer keyboard shortcuts.
Image to Notes - Convert images into notes. Rarely needed.
Kanban - Kanban board inside Obsidian. I find Vikunja better for project management.
LanguageTool Integration - Spell-check in the editor. Good, but I forget it’s there.
PlantUML - Generate UML diagrams from text. Useful for architecture docs, but not daily work.
Prompt ChatGPT - Call ChatGPT from within Obsidian. The Copilot plugin is better.
ToC - Auto-generate table of contents. Nice, but not essential.
Spaced Repetition - Flashcards for review. Strong for certifications, but I don’t actively use it day-to-day.
Weekly Review - Structured weekly review. Good idea, but I do my reviews manually.

Plugins I recommend but haven’t used intensively myself:

Smart Connections - AI-powered local note recommendations. Already described above. Essential once your vault grows.
Obsidian Copilot - Chat with your vault. Already described above. If you want AI in your vault, this is the best plugin for it.
Excalidraw - Hand-drawn sketches and diagrams. Better than Diagrams for quick visualizations.
Custom Attachment Location - Separate attachments folder per note. Solves the image clutter problem from the attachments section.
Meld Encrypt - Encrypt individual notes or folders. Relevant if you’re using multiple vaults.

My recommendation: Start with Tasks, Reminder, Dataview, Templater, Calendar, and Git. Six plugins that deliver value every day. Install anything else only when you have a specific problem to solve. Not because a YouTube video recommended it.

FAQ: Second Brain and AI

How much does Obsidian cost?

Personal use is free. Sync costs €4/month, Publish €8/month. Alternatives: Syncthing or Git.

Obsidian or Notion?

Developers prioritizing privacy: Obsidian. Team collaboration: Notion. Both work well together.

Can I use AI in Obsidian?

Yes, through the Copilot plugin (GPT, Claude, Ollama) or Smart Connections for local recommendations.

PARA vs Zettelkasten?

PARA = folder structure (where), Zettelkasten = linking (how). Use both together.

How do I integrate Obsidian with Windsurf/Cursor?

Via MCP server with vault path in your config file.

Do I need AI for a Second Brain?

No. Start without AI. Add it once you need summaries or gap detection. AI can help with structure, but it often makes you lazier about thinking.

A Second Brain is a system that grows with you. Start simple: install Obsidian, set up PARA, write your first notes. Add AI tools when you need them.

The essential takeaways: Obsidian for your knowledge archive, PARA and Zettelkasten for structure and connections, three sections for job/side business/personal, ChatGPT and Claude to refine your thinking, Windsurf and Cursor with MCP for editor integration, daily routines to maintain it, Spaced Repetition for learning.

If you start today, in six months you’ll have a knowledge archive that helps you with every project, every bug, and every exam.

Täglicher Artikel