How to build a self-improving AI second brain in Claude

Most people love the idea of a “second brain” but never get past screenshots of beautiful Obsidian graphs and Notion dashboards. The setup feels heavy, the maintenance is tedious, and over time everything quietly falls apart. There’s a much simpler way: use Claude as your librarian and let it build and maintain a self-improving knowledge base for you.

The core idea: an AI librarian for your second brain

Instead of you tagging, linking, and organizing everything by hand, you give that job to an AI model. Your role is to capture information; Claude’s role is to ingest it, organize it into a wiki, answer questions, and periodically clean up and improve the whole system.

The setup is surprisingly minimal. You don’t need Obsidian, a vector database, or any complex plugins. Everything runs on simple folders and markdown files that Claude can read and write to through its file tools or Co-work environment.

The simple folder structure that powers everything

The entire system runs on one configuration file and three folders inside a main knowledge base folder. At the top level of a single knowledge base you’ll have:

1. A configuration file: claude.md

This is the brain of your second brain. It tells Claude:

• What this knowledge base is about
• How the folders are organized
• How to ingest new information
• How to write wiki articles and outputs
• How to run health checks and improvements

Think of claude.md as the operating manual for your AI librarian.

2. /raw – your junk drawer

This is where everything goes first. Articles, book notes, screenshots, PDFs, meeting transcripts, clippings from Notion, random ideas—just dump them here. No organizing, no tagging, no structure. The whole point is to make capture effortless and let the AI handle the rest.

3. /wiki – the organized knowledge base

This is where Claude writes the structured version of your knowledge. It creates:

• An index.md file with key topics and links
• Topic pages (one markdown file per concept, framework, or theme)
• Supporting pages like questions, change logs, and more

You never edit the wiki by hand. Claude owns this folder.

4. /outputs – answers, reports, and briefings

Whenever you ask Claude a question based on your knowledge base, it generates a structured answer and saves it here as a markdown report. These outputs then become new input for the system, feeding back into the wiki and making the whole thing smarter over time.

Scaling up: multiple knowledge bases, one system

You can run multiple independent knowledge bases under a single umbrella. For example, you might have a top-level folder like /second_brain_knowledge with subfolders such as:

• /productivity_knowledge_base
• /marketing_knowledge_base
• /research_knowledge_base

Each of these subfolders has its own claude.md, /raw, /wiki, and /outputs. A top-level second_brain.md file can explain to Claude how these individual knowledge bases relate and how to create new ones on demand.

Step 1: set up the structure and instructions

The first step is to create the folders and the core instructions file. If you’re using Claude’s Co-work environment, you can simply tell it to:

• Create a new folder for your knowledge base (for example, productivity_knowledge_base)
• Inside it, create raw, wiki, and outputs folders
• Add a claude.md file in the root of that knowledge base

Then you define what goes into claude.md. A strong configuration file typically includes:

• Purpose and focus – what this knowledge base is for (e.g., productivity, deep work, systems design)
• Folder layout – what each folder is for and what Claude is allowed to edit
• Ingestion rules – how to treat new files in /raw, how to name wiki pages, how to reference sources
• Writing style rules – how to avoid generic AI writing and keep things clear and human
• Health check process – how and when to audit and improve the wiki
• Memory or change log – where to track what changed and when

You can even ask Claude to draft the first version of claude.md for you, then iterate together until it’s clean, simple, and powerful.

Step 2: dump everything into the raw folder

Once the structure is in place, you do a big first pass of ingestion. The goal is not perfection; it’s volume. You want to get as much of your existing knowledge as possible into /raw.

Good candidates include:

• Notion databases of notes, highlights, and research
• Articles you’ve saved or clipped
• Book notes and quotes
• PDFs and slide decks
• Meeting transcripts and call notes
• Screenshots and diagrams

You can move content in several ways:

• Let Claude pull from connected tools like Notion using its connectors
• Copy and paste articles into markdown files
• Use a markdown editor (like a simple desktop app) to create .md files quickly
• Use browser clippers (for example, Obsidian’s web clipper) to save clean markdown versions of web pages

Don’t worry about naming conventions or structure at this stage. The /raw folder is intentionally messy. Claude will later create an ingested registry or memory file to track what it has processed and what’s new.

Step 3: let Claude build the wiki

With a decent amount of material in /raw, you can ask Claude to build the first version of your wiki. A typical instruction looks like:

“Read everything in the raw folder and compile a wiki in the wiki folder following the rules in claude.md. Create index.md first, then one markdown file per major topic, and link related topics together.”

Claude will then:

• Scan all the raw files
• Identify recurring themes, frameworks, and concepts
• Create an index.md that lists key topics and links
• Write individual topic pages (for example, deep_work.md, energy_management.md, habit_formation.md)
• Generate supporting files like a questions log or change log

This is where the system starts to feel magical. Instead of a pile of disconnected notes, you get a structured, cross-linked wiki that reflects how ideas connect across your reading, research, and experience.

Make the wiki actually readable: anti-AI writing rules

One of the biggest risks with AI-written content is that it can feel bland, repetitive, or obviously machine-generated. To avoid this, you can give Claude a writing rules file based on the opposite of common AI habits.

A practical trick is to take a public style guide (for example, Wikipedia’s guidance on AI-generated text), paste it into Claude, and ask it to create a set of internal rules for itself: what to avoid, how to write clearly, and how to keep the tone grounded and specific.

Then, in claude.md, you tell the system to always read and follow that writing rules file before generating or updating wiki pages. The result is a knowledge base that feels like a thoughtful human wrote it, not a generic chatbot.

Step 4: ask questions and save the answers

Once the wiki exists, you can start using your second brain the way it’s meant to be used: by asking it questions that matter to your work and life.

For example, in a productivity-focused knowledge base, you might ask:

• “What’s the best way to balance doing a huge amount in a short time with protecting my energy and health?”
• “Using only what’s in the knowledge base, write a 500-word briefing on ‘doing less but better’.”
• “Based on the wiki, what are the three biggest gaps in my understanding of deep work?”

Claude will:

• Read the index.md and relevant wiki pages
• Generate a structured answer or briefing
• Save that answer as a markdown file in /outputs

A key improvement is to make sure your claude.md explicitly says: whenever Claude generates a substantial answer or report, it should both save it into /outputs and present it in the chat as a clickable page. That way you can read it immediately and know it’s been stored for future use.

Over time, you can also instruct Claude to feed insights from /outputs back into the wiki—updating topic pages, adding new sections, or linking related ideas. Every good answer makes the next answer better.

Step 5: run monthly health checks to keep it accurate

Any knowledge system that grows over time will accumulate errors, contradictions, and gaps. Because Claude builds on its own previous outputs, you don’t want subtle mistakes to compound. That’s where a recurring health check comes in.

A manual health check prompt might look like:

“Review the entire wiki for this knowledge base. Flag contradictions between articles, inconsistent data, and unsourced claims. Identify missing data and, where appropriate, fill gaps with web search. Suggest new connections between articles and propose three new article candidates. For now, just report your findings in the chat; don’t edit any files.”

Claude can then:

• Scan the wiki and change log
• List contradictions and inconsistencies
• Identify claims that lack sources
• Spot unprocessed files in /raw
• Suggest new article topics and connections

You can run this manually, or—if you’re using Claude’s Co-work features—turn it into a reusable skill and a scheduled task that runs monthly. The skill can follow a structured audit process, for example:

• Check for contradictions and broken references
• Review source attribution and provenance
• Compare coverage in /raw vs. /wiki
• Find stale or outdated articles
• Propose and optionally draft new articles

The output is usually a health check report saved in /outputs, plus an updated change log entry so Claude knows what changed and when.

Automating health checks with Claude skills and schedules

If you want to go further, you can define a dedicated "knowledge base health check" skill inside Claude and then schedule it to run automatically. The skill can:

• Read your writing rules and change log
• Audit the wiki and recent outputs
• Generate a structured report with issues, discoveries, and suggested actions
• Optionally ask you which actions to apply, or just apply them automatically

Scheduling this once a month is usually enough. It does consume some API or usage credits, but in return you get a living system that stays accurate, coherent, and useful as it grows.

If you’re interested in building more advanced self-improving skills on top of this pattern, it’s worth exploring how similar ideas are used to create adaptive agents and tools—for example, in guides like how to build self-improving Claude Code skills using Karpathy’s system.

Why this beats traditional note-taking setups

Traditional second brain tools like Obsidian and Notion are powerful, but they assume that you are the librarian. You have to:

• Decide where every note goes
• Maintain tags, links, and hierarchies
• Configure plugins and templates
• Manually keep everything up to date

That’s why so many beautiful setups end up abandoned. The ongoing cognitive load is too high.

In this Claude-based approach, the roles are flipped:

• You capture and ask questions.
• Claude ingests, organizes, writes, links, and audits.

By day one, you have a basic but functional wiki built from your initial dump. By day 100, you have a unique, deeply personalized asset: your sources, your highlights, your questions, all cross-referenced and refined by an AI librarian that knows your system.

It’s the kind of compound advantage that’s hard to copy, because nobody else has read exactly what you’ve read or saved what you’ve saved.

Turning your knowledge base into a working assistant

Once your knowledge base is stable, you can point custom agents or workflows at it and treat it as a specialist assistant. For example, you could create a “productivity strategist” agent that:

• Uses only your productivity knowledge base as its source of truth
• Helps you design weekly plans, deep work blocks, or project strategies
• Writes briefings and checklists tailored to your own principles and references

This same pattern can be used for other domains too—marketing, product strategy, research, or even full SaaS products built on top of AI, like the kind of systems described in how I built an AI market research SaaS with Emergent.

Getting the most from your AI second brain

The real power of this system doesn’t show up on day one. It compounds over months as you:

• Continuously drop new material into /raw
• Ask real questions and save the best answers into /outputs
• Let Claude refine the wiki and run periodic health checks

After a few months, you’re no longer just “using an AI chatbot.” You’re working with a persistent, evolving knowledge base that reflects how you think and what you care about—and that actively helps you do better work with less effort.

If you’re going to implement one AI system this year, this kind of self-improving second brain is a strong candidate. It’s simple to set up, easy to maintain, and becomes more valuable every time you use it.