A second brain is a system that captures what you learn and hands it back when you need it. Fable 5 is a strong engine for one because three of its features line up with exactly what that system needs: a 1M-token context window to hold large chunks of your notes at once, a client-side memory tool that persists across sessions, and Claude Code, which reads and writes your notes as ordinary files. The shortest working setup is a folder of markdown files, Claude Code pointed at it, and a /memories file the model updates as it learns your material. Everything below expands that into a repeatable build.
What a second brain needs from an AI model
Most "AI second brain" walkthroughs skip the part that decides whether it works: what the model has to be able to do. There are three requirements.
Hold a lot at once. Synthesis needs the source material in view. Fable 5 has a 1M-token context window (its maximum is also its default), so you can feed it an entire project folder of notes and get analysis that reflects all of them rather than a truncated slice.
Remember between sessions. A brain that forgets everything when you close the tab is a chat window. Fable 5 pairs with Anthropic's client-side memory tool: the model reads and writes files in a /memories directory that you persist, so what it learned last week is available today.
Connect by meaning, not keyword. Fable 5 keeps thinking on for every request and lets you set an effort level from low to max. That is what turns "here are 40 notes" into "these three contradict each other, and one of them is out of date."
Those are the load-bearing capabilities. The framework below is how you arrange your notes so the model can use them.
The CODE framework, mapped to Fable 5
CODE (Capture, Organize, Distill, Express) comes from Tiago Forte's Building a Second Brain method, and it's a useful spine because each stage maps cleanly onto one Fable 5 capability. Capture and Express are file operations, so they belong to Claude Code. Organize is bulk classification, which the 1M window makes cheap. Distill is what goes into the memory tool. Here is each stage as a concrete step.
Step 1: Capture your inputs
Capture means getting raw material into a place the model can reach. The simplest reachable place is a folder of markdown files, and Claude Code, the filesystem agent built on Fable 5, can read, write, and edit that folder directly with its read, write, edit, glob, and grep tools. You do not need Obsidian; it only gives you a nicer editor over the same plain files.
A folder structure that works:
brain/
├── inbox/ # unprocessed captures land here
├── notes/ # organized, permanent notes
├── archive/ # done or stale material
├── memories/ # distilled notes the model reads back each session
└── skills/ # reusable workflows (see Step 4)Getting started is two steps: install Claude Code, then launch it from inside brain/ so that folder is its working directory and it can see the whole tree. From there, give it a capture instruction it can reuse:
Read every file in inbox/. For each one, write a 2-3 sentence summary at
the top under a "## Summary" heading, then leave the original text below it.
Don't move the files yet; only annotate them in place.That single pass turns a pile of clippings into skimmable notes without you touching them.
Step 2: Organize by filing and linking
Once material is captured, Fable 5 can sort it. This is where the 1M context earns its price: you can hand the model the whole inbox/ and notes/ tree in one request, so its filing decisions are consistent across everything rather than made file-by-file with no memory of the last one.
A prompt that files and tags in one move:
Read all files in inbox/. For each, decide whether it belongs in notes/ by
topic (create a topic subfolder if none fits), or in archive/ if it's stale.
Add a frontmatter block with `tags:` (3-5 topical tags) and `linked:` (paths
to related notes you find). Move the file, then tell me what you did.Because the model sees the existing notes/ structure in the same context, new tags reuse your existing vocabulary instead of inventing a synonym for a tag you already have. That is the failure mode that makes most tag systems collapse.
Step 3: Distill what matters
Distilling is pulling the durable lesson out of a note so you don't re-read the whole thing later. This is the job of the memory tool. It gives the model a persistent memory directory (the memories/ folder above) that it manages with view, create, str_replace, insert, and delete commands, and that directory carries over between sessions. Point Claude Code at it and it reads the folder back at the start of each run, so a distilled insight written today is in context next week without you re-supplying it.
Store one lesson per file with a one-line summary at the top:
As you work through notes/, write durable takeaways to memories/, one file
per idea, a one-line summary on the first line, the supporting detail below.
Record corrections and confirmed conclusions alike, and why each mattered.
Before creating a file, check whether one already covers it and update that
instead of duplicating.A distilled file ends up looking like this — a claim on line one, the evidence under it:
# Vendor lock-in risk is lower with an OpenAI-compatible API than I assumed.
Three of my tool notes show one-line base-URL swaps between providers.
See notes/apis/openai-compat.md and notes/apis/switching-costs.md.Distillation is the stage worth spending effort on: run it at effort: "high" so the model reasons hard about what's worth keeping. Routine capture and filing can run at low or medium to keep costs down. Effort controls how much the model thinks and how many tokens it spends, so matching it to the task is the main cost lever you have.
Step 4: Express your notes as output
Express is the payoff: using the brain to produce something. Package the workflows you repeat as Skills. A Skill is a folder with a SKILL.md file describing a task, and Fable 5 loads it on demand when the task comes up, so you're not re-explaining the workflow every time. A working skills/daily-digest/SKILL.md:
---
name: daily-digest
description: Summarize the last day's captures and distilled memories.
---
Read every file in inbox/ and memories/ modified in the last 24 hours.
Group the items by topic. Write one markdown digest to notes/digests/
named by today's date, with a "## Themes" section and a "## Open questions"
section. Do not modify the source files.Ask Claude Code to run this, or wire it to a scheduler (a daily cron job that starts Claude Code with the digest prompt) so it runs without you asking.
Two caveats. Setting up scheduled or file-watcher triggers takes real configuration work, not a checkbox. And Skills help most for workflows you repeat; a one-off question is faster asked directly.
What it costs to run
Fable 5's API price is $10 per million input tokens and $50 per million output tokens, with a 1M-token context window and up to 128K output tokens per request (verified against Anthropic's pricing on 2026-07-16). A second brain that reprocesses a large note collection daily can move a lot of tokens, so two levers matter.
First, prompt caching: Anthropic caches a repeated context prefix and bills reads at roughly a tenth of the input rate, so feeding the same note vault every day is far cheaper than the sticker math suggests. Second, the API is a standard endpoint. If you route Claude Code through an Anthropic-compatible relay such as AIReiter, which mirrors the Messages API and resells Claude models at a discount, the token bill drops without changing your setup. Both are optional; the default direct API works out of the box.
Common mistakes to avoid
- Capturing without processing. A
brain/full of un-summarized clippings is a landfill, not a second brain. The Organize and Distill passes are what make it searchable, so run them rather than only capturing. - Putting secrets in memory files. The
/memoriesdirectory is read back into every future session. Never write API keys, passwords, or tokens there; keep credentials out of anything the model persists. - Running everything at max effort. High effort is worth it for distillation and synthesis; using it for routine filing burns tokens and can make the model overthink a simple sort. Match effort to the task.
- Feeding it one note at a time. The 1M context exists so you can organize in bulk. Handing over files individually loses the cross-note consistency that makes the system cohere.
Frequently asked questions
How is Fable 5 different from other Claude models for this?
Fable 5 is Anthropic's most capable widely released model, with a 1M-token context window and always-on reasoning you tune with effort levels. That combination of large context and strong synthesis is what a second brain leans on. It also costs more than the Opus tier ($10/$50 per million tokens); for lighter filing work you can run a cheaper model and reserve Fable 5 for distillation. See this high vs. max effort breakdown for tuning.
Do I need Obsidian, or can I use plain markdown files?
Plain markdown files in a folder are enough. Claude Code reads the filesystem directly, so any editor works. Obsidian adds backlinks and a graph view on top of the same files, which some people like, but it's optional.
How do I make my second brain remember across sessions?
Use the memory tool. It gives the model a /memories directory it can read and write, and that directory persists between conversations. Anything distilled into it is loaded automatically next time, which is what separates a second brain from a stateless chat.
What is the CODE method?
CODE stands for Capture, Organize, Distill, Express, a four-stage knowledge-management workflow from Tiago Forte. It's used here as the spine because its four stages split cleanly along Fable 5's capabilities: Capture and Express are file operations for Claude Code, Organize is bulk work for the 1M context, and Distill is what the memory tool persists. Other frameworks (the Four C's, or Applications/Routines/Memory/Skills) map to the same features; CODE just draws the lines in the most useful place for an AI-run system.
Is it safe to give an AI access to all my notes?
The notes stay in local files you control, and Claude Code acts on them through tools you can see. The two things to watch: don't store credentials in files the model persists, and note that Fable 5 requires 30-day data retention (it isn't available under zero-retention), so check that against your own privacy needs before pointing it at sensitive material.