# Building a Second Brain — Stone Arch Collective > How to build an AI assistant that remembers you — your projects, decisions, and follow-ups — and compounds every week. URL: https://stonearch.ai/resources/building-a-second-brain --- [Back to Resources](https://stonearch.ai/resources) 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 one idea A second brain is not a smarter chatbot. It is a filesystem of memory that an AI reads at the start of every session and writes back to at the end. Get that loop right and the system compounds; skip it and you have an expensive autocomplete. ## 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. Context vs. memory Context is what the AI holds during one conversation — finite, and gone when the session ends. Memory is what survives on disk. The craft is deciding what graduates from context into memory, and writing it down before the session closes. ## 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. CLAUDE.md — global ``` 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. memory/example-fact.md ``` --- 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. Want help building your own? Stone Arch Collective runs workshops on putting AI to work for schools, nonprofits, and small organizations. [Start a conversation →](https://stonearch.ai/work-with-us) [Back to Resources](https://stonearch.ai/resources)