Stop Treating Claude Code Like ChatGPT. I Built It a Second Brain in Obsidian.

How a solo founder turned a markdown vault into a persistent memory system for AI agents, and the skills that compound on top.

claude-code-second-brain

How I found this method

In early April 2026, Andrej Karpathy posted a tweet I cannot stop thinking about.

LLM Knowledge Bases. Something I’m finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest.

— Andrej Karpathy, April 3, 2026

This was not new in spirit. Tiago Forte sold the Building a Second Brain methodology to half the productivity internet. Zettelkasten goes back to a German sociologist with index cards in the 1960s. Both were about humans remembering things. Karpathy flipped the same idea for LLMs.

I read the tweet on a Friday. I rebuilt my workflow that weekend. Two months in, the system runs the company.

This is what I built, why it works and the skills and plugins that compound on top.

Who I am, why this matters

I am a solopreneur, run my company alone.

One founder, one keyboard, one terminal. No engineers, no PM, no marketing hire. Claude Code is the team. Obsidian is the office.

Six months ago I used Claude Code like ChatGPT. Open the session, paste the file, explain what we did yesterday, watch the model do good work, close the terminal. Tomorrow, repeat.

The model never remembered. I did not realize how expensive that was until I measured it.

The Amnesia Problem (and what it costs)

Default Claude Code is stateless. Every session starts cold. Nothing in the previous conversation survives.

This is fine for one-off chats. It is brutal for running a company.

The cost is three-shaped.

Time. I re-explained the project map, recent decisions, and open tasks every morning. Conservatively, fifteen minutes per session, three sessions a day. That is forty-five minutes of pure context bootstrap, every working day.

Tokens. Re-pasted context burns input tokens. Long history pastes blow past the prompt cache TTL, which means cache miss, which means the model re-reads everything from scratch. Token throughput goes up, latency goes up, the bill goes up and the model has not done any new work yet.

Decision drift. Worst of the three. Without persistent memory, the model has no way to remember we already decided against a given pattern. So it proposes it again. I either catch it (cognitive tax) or I do not (wrong direction).

The fix is not a bigger context window. The fix is persistent context the model reads at session boot and writes back to during the session.

The three memory layers

I borrowed the structure of Claude Code itself. It already supports three layers of context. Most users only use one.

┌──────────────────────────────────────────────┐
│  Layer 1: GLOBAL                             │
│  ~/.claude/CLAUDE.md                         │
│  Loaded for every project, every session.    │
│  Preferences, vault path, write rules.       │
└────────────────┬─────────────────────────────┘
                 │
                 ▼
┌──────────────────────────────────────────────┐
│  Layer 2: PROJECT                            │
│  <project>/CLAUDE.md                         │
│  Loaded when working in that project.        │
│  Voice rules, file map, conventions.         │
└────────────────┬─────────────────────────────┘
                 │
                 ▼
┌──────────────────────────────────────────────┐
│  Layer 3: VAULT                              │
│  Obsidian markdown files.                    │
│  Decisions, tasks, updates, patterns.        │
│  Read on demand, written on outcome.         │
└──────────────────────────────────────────────┘

Layer 1 is the contract. It says: here is where the vault lives, here is when to write to it, here is how I want decisions formatted, here are the banned phrases.

Layer 2 narrows the contract. Per project: which sub-voice, which folder structure, which files mirror to which central index.

Layer 3 is the actual second brain. Plain markdown files in Obsidian. Read when needed. Written when something happens worth remembering.

The vault

The vault folder layout looks like this.

obsidian-vault

~/Programming/Claude Memory/
├── MEMORY-INDEX.md          ← session boot reads first
├── TASKS.md                 ← central task board
├── Projects/
│   ├── Podwist/
│   │   ├── overview.md
│   │   ├── decisions.md
│   │   ├── tasks.md
│   │   └── updates/
│   ├── ClientX/
│   └── ...
└── preferences.md

MEMORY-INDEX.md is the table of contents. *TASKS.md is one row per open task across every project. `Projects/{name}/`* has overview, decisions, tasks and a folder of dated updates.

The format of a decision entry is fixed.

obsidian-vault-second-brain

## 2026-06-15 — Stop using SaaS PKM, move to vault

**Status:** decided
**Tags:** #arch #workflow

### Context
SaaS tools (Notion, Linear) lock my data behind APIs the LLM cannot read directly.

### Decision
Move everything to plain markdown in an Obsidian vault. Wikilinks for cross-refs. Git for history.

### Consequences
Lose Notion's UI polish. Gain LLM-readable context, free hosting, offline access, full ownership.

Why Obsidian and not Notion, Linear, or anything else.

Markdown is the LLM’s native tongue. No API, no auth dance, no scraping. The model reads files. Wikilinks let me cross-reference notes without thinking about IDs. The graph view turns the vault into a visual map of how the company thinks.

obsidian-graph-second-brain

That graph is the second brain.

The skills stack

Skills are installable behaviors for Claude Code. Plugins are bundles of skills and tools. Both extend the default behavior beyond what comes out of the box.

I run ten that pay rent. Here is the trigger map.

USER INPUT
    │
    ├── "/brainstorm idea"     → superpowers:brainstorming
    ├── "/gsd next"            → gsd (project + task mgmt)
    ├── "/caveman"             → caveman (terse output)
    ├── "write LinkedIn post"  → marketing-skills:copywriting
    ├── "/graphify ."          → graphify (project → graph)
    ├── "edit vault file"      → obsidian-cli
    ├── "build component"      → frontend-design
    ├── "review UX of screen"  → ui-ux-pro-max
    ├── "design API"           → system-design
    └── "write brand post"     → podwist-brand-voice (custom)
              │
              ▼
       Skill loads,
       overrides defaults,
       executes pattern.

Quick tour.

1. superpowers:brainstorming: Vague idea in, structured spec out. Forces a design before any code. Saves me from building the wrong thing all weekend.
2. gsd: Get-stuff-done family. gsd:new-project, gsd:plan-phase, gsd:next, gsd:complete-milestone. Replaces a PM. Phases become files. Tasks become rows.
3. caveman:caveman: Cut the fluff. Fragments instead of paragraphs, code stays byte-perfect. I read three times faster.
4. marketing-skills: Copywriting, content strategy, SEO audits, page CRO, email sequences. A marketing department compressed into invokable skills.
5. obsidian-cli: Lets the model read and write vault files from inside a session. Without this, the vault is a one-way archive. With it, the vault is alive.
6. graphify: Run /graphify . and any project folder becomes a searchable knowledge graph: code, SQL, docs, even PDFs. Then I ask ”what connects X to Y?” from the terminal without re-reading the codebase. Graphify maps the code, the vault maps the thinking.
7. frontend-design: Design system reasoning, component patterns, accessibility checks. The solo founder is also the solo designer.
8. ui-ux-pro-max: Full UX critique. Takes a screen, returns a six-pillar audit. Catches the stuff I stop seeing after staring at the same screen for a week.
9. system-design: Architecture patterns, decomposition, API design, scaling decisions. The principal engineer I do not employ.
10. podwist-brand-voice: A custom skill I wrote myself. Encodes the brand voice rules, banned phrases, sub-voice splits, and format defaults. Every post written touches this skill first.

That last one matters most. You can write your own skills. Once you do, your accumulated taste compounds. The model gets better at sounding like you with every rule you add.

Closing the loop on quality: code-review, simplify, verify, run. The engineering team I do not hire, on call from the terminal.

How it compounds

A concrete week.

Monday I ship a feature. The model logs the decision in *Projects/Podwist/decisions.md*. The reasoning includes the alternative we rejected and why.

Wednesday I open an unrelated project. We hit the same architectural fork. The model reads the decision from Monday, surfaces the reasoning, and references it by date. I do not re-think the trade-off. I extend the prior thinking.

Friday the marketing engine asks for a LinkedIn post. The model loads the brand voice skill and writes in the right register without me reminding it of the banned phrases.

Sunday I take notes on a customer call. The next morning the model reads those notes alongside the open tasks, sees the gap between what the customer asked for and what is on the roadmap and proposes the right next task.

The math of the solo company changes. One founder plus persistent memory is not three employees with Slack history. It is something else. The team does not forget. The decisions do not drift. The voice does not slip.

I do not onboard new context every morning. I extend it.

Closing

Claude Code without memory is rented intelligence. You pay per session, you start over each time, and nothing you teach it lasts.

With a vault, it is an asset. Setup is a weekend. Compounding is forever.

Two things before you go.

What is in your vault? I am genuinely curious which folders other solo builders track. Drop a structure in the comments. The good ones get stolen and credited.

If this was useful, I write about solo AI-native engineering on X as **@mesutas_dev** and here on Medium. Follow for more from the one-keyboard company.