Building a Second Brain

Most people use AI like a vending machine: ask, get an answer, walk away. The next conversation starts cold. A second brain fixes the amnesia. You give the AI a set of files it owns and maintains — what it knows about you, what's true about each project, what you've asked it to remember, what's on your plate — plus a protocol for keeping those files current. Every session then builds on the last.

The mental model — six layers

A second brain is six layers on a plain folder of text files. Each works alone; together they reinforce each other.

1. Instructions (the constitution) — standing rules the AI reads every session: who you are, how to behave, what each project is.
2. Memory — durable facts captured over time: decisions, preferences, the texture of people and projects.
3. Tasks — one tracked list of what's owed, by whom, by when, with stable IDs so it can be updated precisely.
4. Connectors — email, calendar, drive, chat, your database, so the AI reads live state instead of guessing.
5. Automations — scheduled jobs: the morning briefing, the inbox sweep, the weekly recap.
6. Skills — reusable playbooks the AI follows the same way every time.

Step 1 — The constitution (CLAUDE.md)

The highest-leverage file in the system: standing instructions the AI reads at the start of every session. Write a global one that governs everything, and a per-project one for each project's facts and rules. The most valuable instructions compensate for your own blind spots.

You are my personal assistant across all areas of my work and life.
I miss details and forget follow-ups — proactively catch what I'm missing.

Always:
- Flag what I've forgotten or overlooked; name next steps I haven't.
- Ask clarifying questions before any task that's risky if done wrong.
- Summarize what you did and what's still on me when you finish.
- Keep outputs simple: bullets and short summaries.
- Surface conflicts (double-bookings, duplicates, gaps) before acting.

I run multiple projects — if it's not obvious which one a task is for, ask.

Step 2 — Memory: what it learns over time

The constitution holds what's true on day one; memory holds what the AI learns afterward. The pattern that scales: one fact per file, plus a single index file that lists them all. Each fact-file gets a short header so the AI can judge relevance without opening everything.

---
name: legal-structure
description: How the org is structured + pay implications
metadata:
  type: project   # user | feedback | project | reference
---

Co-op operating as an LLC. Member pay is likely K-1 patronage, NOT
1099/W-2 — confirm with a co-op-savvy CPA before any payments.

The four kinds of memory worth keeping: User (who you are, preferences), Feedback (how the AI should work, with the "why"), Project (ongoing goals and constraints), Reference (pointers to things you reuse). Don't store what the files already say, one-off trivia, or sensitive data (IDs, account numbers, passwords) unless you've decided to.

Step 3 — The task tracker

Open loops are where things fall apart. Keep ONE file, owned by the AI, as the single source of truth for what's owed. Give every task a stable ID that never changes or gets reused — IDs let the AI update one task precisely instead of rewriting the whole list. Add a short merge protocol (match by ID, change only named fields, never blindly overwrite, archive what's done, flag conflicts instead of guessing) and a change log so you can see WHY each task exists. Never run two task lists — things fall between them and you stop trusting both.

Step 4 — Connect your tools

Connectors let the brain reach live systems so it reads real state. Connect in order of how often you'd say "go check ___": email (triage, drafts, catch promises), calendar (agenda, double-booking alerts, prep), drive/files, chat, meeting notes, your database. Guardrail: a safe default is the AI can READ freely and DRAFT anything, but SENDING, PAYING, or DELETING waits for your yes. For money: it never moves funds — it prepares, you execute.

Step 5 — The session protocol

This is the loop, made concrete, and it's the single habit that makes the system compound.

• START: the AI reads the global constitution, the memory index, and the relevant project's instructions + handoff log before doing anything.
• WORK: collaborate as normal.
• END: before the session closes, it records what changed — new facts to memory, task updates by ID, a dated line in the project's handoff log.

"At session start, read global memory plus the relevant project memory. At session end, write back what changed. That one write-back rule is the whole game."

Make write-back a standing instruction in your constitution so it closes itself.

Step 6 — Automate it

Scheduled tasks are saved instructions that run on a schedule with no one at the keyboard. A starter set: a weekday morning briefing (calendar, key email, items needing a reply, forgotten follow-ups, meeting prep), an industry-news digest, an inbox sweep that labels mail and flags stale items, and a weekly recap. The design rule: automations should DRAFT and SURFACE, not send and delete. You stay the decision-maker.

Step 7 — Skills: reusable playbooks

A skill is a named procedure the AI runs the same way every time, so quality doesn't drift. Any workflow you've explained more than twice is a skill waiting to be written ("prep me for a sales call" = research the company, pull our history, draft an agenda, list the risks). Use shipped skills for format (docs, decks, research); write your own for the procedures specific to how you work.

How to start

The basic setup — a folder, a CLAUDE.md, your first session — takes about an hour. Dialing it in takes a few more sessions. Most people see real time savings within the first week. If you only do three things: keep ONE task list, give the brain a single front-door index file, and make write-back automatic.