Autonomous Second Brain: Organize and Connect Notes Automatically While You Sleep with Claude Code × Obsidian

This year, I saved about 200 articles. Yet, all I have left are 40 notes and a "To Organize Later" folder that I never open.

It's not your fault that notes pile up without being useful. Every note-taking method assumes you will personally continue the work of "collecting, organizing, relating, and reviewing" forever. Almost no one can keep this up in a busy daily life. It's not a matter of willpower; it's simply too much effort.

What if there was a system that took over that tedious organization while you slept? During the day, you just throw your ideas into notes. At night, your messy scribbles are neatly organized, related notes are automatically linked, and you're even given pointers like "This contradicts your note from three weeks ago," all laid out on your desk by morning.

Moreover, you can build this yourself right now without any special environment. All you need are Claude Code and Obsidian—standard tools that run on your own computer. In this article, I will explain how to build this system, step-by-step, starting today.

My name is tatsuki (@nobel_824). I support AI utilization for small and medium-sized enterprises, helping with the implementation of Claude/Codex while running Claude Code myself all day long.

The inspiration for this design comes from a build guide titled "How To Build a Second Brain That Runs Itself With Kimi & Obsidian (Full Course)," which garnered 1.48 million views overseas. The concept is excellent, but the tool doesn't have to be Kimi Work. The important part is the design philosophy of "outsourcing organizational labor to a nightly batch process," which is tool-agnostic. So, I've rebuilt it using the tools I use daily: Claude Code and Obsidian.

Related Article: Claude Code Textbook - Basics -

https://note.com/nobel/n/n7d7a422f828f

Chapter 1: Creating a "Night Shift" for Your Second Brain

First, let's share a perspective that makes the big picture easy to grasp.

Think of your Second Brain not as an "app," but as a "small department specialized in night shifts." You are the only one on the day shift. During the day, you do what humans are still better at than machines: coming up with ideas, noticing things, reacting, and just throwing things in. You just toss the raw materials over the wall.

At night, a different department starts moving. They process what you threw in during the day, turn it into organized knowledge, and prepare a briefing (summary report) before your first cup of coffee. This was impossible until recently because the "night shift" didn't exist. At best, you had an assistant who only worked while you sat next to them giving instructions. That just added to your own workload. A true Second Brain needs a labor force that works according to a schedule, in parallel, and without supervision.

The night shift team isn't just 300 copies doing the same task. Their power comes from dividing roles, like a real research department. The flow is simple and consists of four stages.

First, Collect. This role fetches the text of articles or pages you want to read and brings them into the building.

Second, Break Down and Link. This role decomposes the collected material into "one idea, one note." A single article might become eight notes. Every time a new note is born, it's linked to existing related notes. This turns a pile of files into a web of thought.

Third, Check for Contradictions. This is the most valuable role. It compares new notes against all existing notes to find friction—claims that conflict with your past notes, assertions without sources, or points that quietly undermine a belief you wrote last month. If found, it raises a flag. it doesn't just overwrite and suppress them.

Fourth, Summarize and Report. This role weaves related notes into a single long document and writes the morning briefing. It transforms raw knowledge into a form you can actually use for thinking.

Why does parallel processing work? On a quiet night, there are only a few materials to process and a few agents running. But on a night after a busy week with 50 articles piled up, you can assign one agent per source and deploy them all at once. A task that would take one agent hours to do file-by-file can be split, run simultaneously, and integrated in minutes. This is what it means to "make it a team."

Chapter 2: Holding Knowledge in a "Refinery," Not a Drawer

Now, let's get to work. We start with the design of the vault.

The most common mistake is organizing a vault by topic—creating drawers labeled "Marketing," "Health," or "AI." This fails because real knowledge doesn't stay in one category. Having an agent sort things into topic folders just recreates the organization problem on a larger scale.

Instead, we create folders based on the stage of refinement. Raw material enters from one side and comes out as connected knowledge on the other. The folder structure itself becomes the pipeline.

Step A: Create Folders (5 minutes)

Run this one-liner in your terminal to create the refinery.

1mkdir -p brain/{0-raw,1-desk,2-atoms,3-threads,sources,briefings,.claude/skills}
2touch brain/CLAUDE.md

Here are the roles for each:

brain/

├── 0-raw/ # Where you throw things. Do not touch. The input.

├── 1-desk/ # The night shift's workbench. Temporary. Cleaned at the end of the shift.

├── 2-atoms/ # Permanent notes: one idea per file. The core.

├── 3-threads/ # Integration. Living documents woven from multiple atoms.

├── sources/ # Original articles or PDFs. Read-only storage.

├── briefings/ # Reports from the night shift to you.

├── .claude/skills/ # "Job descriptions" for each shift.

└── CLAUDE.md # Operational charter. Read by all agents first.

There are three key design decisions in this layout.

First, 0-raw and sources are read-only and never modified. Raw notes and original files are the foundation of truth. Agents create derivatives from them but never touch the originals. This prevents the failure that quietly destroys AI knowledge bases: "derivative notes quoting other derivative notes, drifting slightly from the original meaning with each regeneration until the AI confidently repeats things it made up." Since the source doesn't move, the truth doesn't drift.

Second, 2-atoms contains atoms (single ideas), not articles. One file, one idea. This is the principle of Zettelkasten and the key to making the web of links functional rather than decorative. By breaking things down into single ideas, you can link them to many things, recombine them, and accurately identify contradictions. You can't do this in a vault where long articles are thrown in whole.

Third, 3-threads is where understanding lives. Atoms are materials; threads are integration. As related atoms accumulate on a theme like "Battery Cost Curves," the thread grows. This is a layer missing from flat wikis, and it's the difference between a "knowledge base" and "understanding."

Step B: Open this folder in Obsidian

This is the basis of Obsidian integration. You only need to do one thing.

Open Obsidian and select "Open folder as vault," then point it to the brain/ folder you just created. That's it. You don't need extra plugins or sync services because an Obsidian vault is just a collection of markdown files. The folder itself becomes the vault.

When you write [[Note Name]] in a note, it becomes a standard Obsidian internal link. This means if the night shift's "Break Down and Link" role connects notes with [[Related Note]], those connections will automatically appear in Obsidian's Graph View. You don't have to do anything. Obsidian visualizes the markdown written by the agents.

You might wonder, "Why not use a Vector DB or RAG?" Because plain markdown and links are sufficient. It's local, portable, and you can track which note came from which source. It beats a cloud-based Vector DB in both portability and reliability. Obsidian works as a viewer precisely because the files are plain text.

Step C: Write a Charter

CLAUDE.md is the single file that governs this entire workforce. Claude Code reads this file before working, so if you write operational rules here, all shifts will follow them. Write them briefly, clearly, and absolutely.

1# Operational Rules (Must read before acting)
2
3## Pipeline
4- 0-raw/    : Input. Read-only. Never edit raw notes.
5- 1-desk/   : Workbench. Clean up at the end of the shift.
6- 2-atoms/  : Permanent atoms. One file, one idea.
7- 3-threads/: Integrated documents. Update existing threads without creating duplicates.
8- sources/  : Originals. Read-only.
9- briefings/: Where reports to humans are written.
10
11## Prime Directive
12Every atom must be traceable to an existing source in sources/ or 0-raw/.
13Do not write a note if there is no source. Do not write claims not found in the material.
14Do not fill in gaps with plausible-sounding information. Ever.
15
16## Work Rules
171. One atom, one idea. If a source has 8 ideas, create 8 atoms.
182. Search 2-atoms/ before creating an atom to see if an existing note can be expanded.
193. Each atom must link to at least two related atoms.
204. If it contradicts an existing note, add a [FRICTION] block to the new note pointing to the old one. Do not silently overwrite beliefs.
215. Do not delete. If it becomes obsolete, add [RETIRED] and move to archive/.
226. Update relevant threads and write a briefing at the end of the shift.

The "Prime Directive" is the line that protects everything. Without it, the night shift will start filling gaps between facts with plausible fictions. Those fictions will become indistinguishable from your own real thoughts, and a month later, you won't know which beliefs are yours and which the machine made up. "Do not write a note if there is no source." This is the rule that keeps your brain your own.

Now you have the box for knowledge and the charter to protect it. The notes inside will be added by the night shift team in the next chapter.

Chapter 3: Running the Night Shift with Claude Code

Now that the blueprint is ready, let's install the engine. Claude Code is what actually runs the night shift. Let's assemble it.

Headless Execution: Run it manually once

Claude Code can run without an interactive screen. This is the headless mode.

claude -p "Read one unprocessed file from 0-raw/ and create an atom in 2-atoms/ according to the rules in CLAUDE.md"

The -p (--print) flag is a mode for scripts that executes one instruction and exits (Official Docs). Standard claude -p automatically reads CLAUDE.md and skills, so the Prime Directive you wrote in Chapter 2 will apply. If you need perfect reproducibility, there is a --bare mode (which skips automatic discovery of CLAUDE.md and skills), but in that case, you must pass the rules explicitly in the prompt. Since we want the Prime Directive to work, we use the standard -p.

Don't schedule it immediately; run it manually once to see how it behaves. Confirm that one atom is created as intended before moving to automation.

Write the Playbook as a Skill

The "job description" for each shift is written as a Skill (a markdown file describing a reusable workflow). If you place it in .claude/skills/<name>/SKILL.md, you can call it anytime (Official Docs).

For example, the "Refinery" shift, which handles the main nightly processing, is written like this. Once written, you can call it by skill name, like claude -p "/refinery". You write it once and just call its name every night.

name: refinery

description: The main nightly shift to refine all unprocessed items in 0-raw into atoms.

1# Refinery Run
2
3## Task
4Process unprocessed items in 0-raw/. Assign one sub-agent per item,
5run them in parallel, and then integrate. Each agent will:
6
71. Read the raw note and related sources in sources/.
82. Split into one idea per file and place in 2-atoms/.
93. Search 2-atoms/ for each atom to see if an existing note can be expanded before creating a new one.
104. Link each atom to at least two related atoms.
115. If it contradicts an existing note, add a [FRICTION] block pointing to it.
126. Move processed raw notes to 0-raw/archive/.
13
14## Strict Adherence
15- Follow the Prime Directive in CLAUDE.md. Do not write claims without sources.
16- Do not touch originals in sources/ and 0-raw/ except to read them.
17- Leave integrations that require judgment to humans. Flag them; do not force a decision.

Parallelism: Defining Sub-Agents

To divide the tasks of "breaking down," "linking," and "checking contradictions," we use sub-agents. By defining them in markdown under .claude/agents/, each moves in an independent context in parallel and returns only the results to the parent (Official Docs). The definition file starts with frontmatter specifying the name and available tools.

name: cataloger

description: Decomposes one source into atoms (one idea per file).

tools: ["Read", "Write"]

Read the provided source and create atoms in 2-atoms/ (one idea per file). Search existing atoms first and expand those that can be expanded. Always write the source in the frontmatter.

The original article boasted "300 agents." This comes from the specification of Kimi's K2.6 model, which can deploy up to 300 sub-agents and 4,000 steps in parallel (Kimi Official Blog). However, Claude Code doesn't advertise a fixed number like "limit 300"; it uses an orchestration method to assign and integrate multiple agents as needed. And in reality, you don't need 300 agents for a Second Brain night shift. A few types of roles and a few agents per accumulated source are enough. The benefit comes from dividing roles and running them in parallel, rather than the sheer number.

Scheduling: Calling at a Fixed Time Every Night

Finally, trigger the shifts by time. The most reliable way is to call the skill by name using standard claude -p from an external cron job. Design it so four shifts take over in sequence through the night.

0 23 * 23:00 Daily Scout (Collect materials; run manually for now)

0 3 * 3:00 Daily Refinery (Refine in parallel; the main event)

0 6 * 6:00 Daily Editor (Update threads and briefings)

0 22 0 22:00 Sunday Audit (Weekly health check)

Automating just the Refinery is enough to start. Here is an example for crontab:

Example for crontab -e (3:00 Refinery shift)

0 3 * cd ~/brain && claude -p "/refinery" >> briefings/cron.log 2>&1

The Scout role—fetching article text via a browser—is a special case. As mentioned later, Claude Code's browser operation is currently limited to interactive sessions, so for now, run Scout manually to save text to sources/, and let the nightly Refinery process that collected text.

Once you're used to it, moving to Claude Code's built-in Routines is easier (Official Docs). Running /schedule within a session allows you to register periodic executions like hourly, nightly, or weekly (as of writing, this is a research preview requiring specific plans or Claude Code on the web). Routines run on Anthropic's cloud, so jobs run even if your laptop is closed. The minimum interval is one hour. I recommend starting with cron for one shift and moving to Routines once you're comfortable.

Chapter 4: Making Obsidian the "Shared Memory for All Tools"

So far, Claude Code can directly read and write to the brain/ folder. Since Obsidian is opening the same folder, the basic integration is already complete.

This chapter is the advanced version. If you just want to get the night shift running, you can skip this and read it later. Here, we make the same vault searchable and writable from other tools, such as AI features in other editors or different agents.

This eliminates knowledge silos scattered across five apps, allowing everything to share a single brain. This is achieved through MCP (Model Context Protocol, a common standard for connecting external tools to AI).

There are three ways to connect Obsidian as an MCP, in order of difficulty:

1. Filesystem MCP (Easiest, no plugin required)

Since the vault is just a folder, you can point a filesystem MCP server at the vault. You don't need to install anything in Obsidian.

claude mcp add obsidian-fs -- npx @modelcontextprotocol/server-filesystem ~/brain

2. Local REST API + mcp-obsidian (Full features: search and append)

If you want the AI to perform full-text searches or append to specific headings/blocks, use the "Local REST API" community plugin in Obsidian. Just install and enable it, then copy the API key. The default host is 127.0.0.1, port 27124 (HTTPS with self-signed cert). Then, register uvx mcp-obsidian with environment variables (mcp-obsidian / Local REST API).

OBSIDIAN_API_KEY=your_key OBSIDIAN_HOST=127.0.0.1 OBSIDIAN_PORT=27124 claude mcp add obsidian -- uvx mcp-obsidian

3. A richer implementation (cyanheads/obsidian-mcp-server)

There is also a more advanced MCP server implementation that wraps the Local REST API plugin. cyanheads/obsidian-mcp-server is an external Node-based server that supports path restrictions and precise editing by heading. Like method 2, it requires the Local REST API plugin and an API key.

Registering an MCP in Claude Code always follows the format claude mcp add <name> -- <command>, and settings go into ~/.claude.json (for yourself) or .mcp.json (for repository sharing) (Official Docs).

One warning: all these methods are scoped to localhost or the provided folder. The REST API method requires your own API key and communication is limited to localhost. Still, since you are giving an agent write access, it's safest to limit it to trusted vaults.

Three Pitfalls Demo Videos Always Skip

Giving an automated workforce read/write access to your knowledge and letting it run unattended overnight is a huge leverage, but there are points to observe. This is what separates a system that gets smarter over a year from one that quietly rots in a month.

First, honestly understand the constraints. Routines run in the cloud with a minimum interval of one hour. And the "Scout" shift—fetching article text via browser—requires caution. Claude Code's browser operation (Claude in Chrome) is currently in beta and limited to interactive sessions. It doesn't work inside cloud Routines yet (Official Docs). Practically, it's cleaner to run Scout manually to save text to sources/ and let the nightly Refinery process that collected text.

Second, security and costs. Claude Code has multiple permission modes (Official Docs). The standard default asks for approval for anything other than reading; acceptEdits automatically allows edits; plan investigates and proposes a plan in read-only mode; bypassPermissions allows everything. For unattended operation, it's safest to verify behavior with plan first, then move to dontAsk (a mode for CI that only runs pre-authorized tools) while using Deny rules. Additionally, manage brain/ with git and commit every night. If the night shift makes a strange decision, you can revert to the previous night with one command. This is a seatbelt; it's better to buckle up on day one rather than after an accident. Also, Claude Code incurs API or subscription costs. You could host open-weights models yourself to zero out API charges as in the original guide, but that's a separate topic. Just be prepared to estimate costs based on the volume of nightly processing.

Third, keep following the Prime Directive. If the weekly Audit finds "notes without sources," deal with them immediately. The moment notes with untraceable sources start accumulating, your brain becomes untrustworthy. An untrustworthy Second Brain is worse than none at all because you might act on a machine's fiction thinking it's your own conclusion. "Do not write a note if there is no source." This is the rule to keep your brain your own.

Summary: Stop Being a Librarian, Become an Editor-in-Chief

For a long time, "building a second brain" was a polite way of saying "taking on a second unpaid job as your own librarian." That's why there are graveyards of failed attempts everywhere. The labor wasn't worth it, so willpower always lost.

But that labor can now be delegated. During the day, you just throw things in for a few seconds. At night, the troops refine them. You spend just 20 minutes a week as the editor-in-chief, deciding "which beliefs to adopt." And the system gets smarter the more you leave it alone, because you've handed the labor that used to decrease over time entirely to the night shift.

You weren't bad at note-taking. You were just trying to run a research department all by yourself.

First steps from today (3 steps):

• [ ] Create the refinery with mkdir -p brain/{0-raw,1-desk,2-atoms,3-threads,sources,briefings,.claude/skills} and open it as a vault in Obsidian. Write the Prime Directive "Do not write a note if there is no source" on the first line of CLAUDE.md.
• [ ] Write one SKILL.md for .claude/skills/refinery/ and try processing one source manually with claude -p.
• [ ] If it works, automate one shift nightly with cron or Routines.

I share useful information that I can't post on X in a LINE OpenChat.

Please join us via the link below.

https://t.co/9LOoUYvCbO

https://x.com/nobel_824/status/2066393004932559265