DEV Community: Mike Dolan

I Wrote 500 Lines of Rules for Claude Code. Here's How I Made It Actually Follow Them.

Mike Dolan — Tue, 07 Apr 2026 19:45:54 +0000

CLAUDE.md is supposed to be the operating manual for Claude Code. You write your rules, preferences, project context, and workflow instructions. Claude reads it at session start and follows your instructions.

Except it doesn't. Not reliably.

If you have used Claude Code for more than a few sessions, you have seen it ignore your CLAUDE.md rules. Not maliciously. It just prioritizes answering your question over following a protocol. It skips steps, forgets constraints, and does things you explicitly told it not to do.

I have 500+ lines of rules across CLAUDE.md, SESSION_PROTOCOLS.md, and MEMORY.md. After months of Claude ignoring them, I stopped writing more rules and started enforcing the ones I had. The fix was not better rules. It was hooks.

The Problem: Rules Without Enforcement

Here is what happens with CLAUDE.md rules in practice:

Claude skips the session start protocol. I have a 7-step checklist that Claude must complete before doing anything else: search the brain database, read the project tracker, review unfinished items, show me the last session's notes. Claude skipped this in sessions 35, 38, and 39. It jumped straight into whatever I asked and ignored the checklist entirely.

Claude codes without permission. I have a rule that says "NEVER write, edit, or modify code unless Mike says GO with a specific step or fix." Claude violated this in sessions 17, 19, 21, and 25. Each time it started coding before I approved the plan, creating complexity and wasted work.

Claude forgets rules after compaction. When the context window fills up and Claude Code auto-compacts, the CLAUDE.md gets re-read but the nuance is gone. Claude follows the broad rules but skips the specific ones buried deeper in the file.

Claude prioritizes helpfulness over compliance. If you ask a question, Claude wants to answer it immediately. The idea of stopping to run a checklist first feels counterproductive to the AI, so it skips it. Your rules say "do this first." Claude's instinct says "answer the human."

This is not a bug. It is a fundamental limitation of instruction-following. Rules in a text file are suggestions. The AI decides whether to follow them based on how important they seem relative to the current task. Your carefully written protocol loses to "the user asked me a question and I should answer it."

Why More Rules Don't Help

The instinct is to write more detailed rules. Add more context. Be more explicit. Bold the important parts. Add warnings about past violations.

I tried all of this. My CLAUDE.md grew from 50 lines to 200 to 500+. I added violation history ("Violated in sessions 17, 19, 21, and 25. Each violation caused complexity and wasted time. ZERO tolerance."). I added bold warnings. I added all-caps headers.

It helped marginally. Claude followed the rules more often. But "more often" is not "always." And for rules that matter, "usually" is not good enough. If "do not code without permission" works 90% of the time, the 10% where it fails costs hours of rework.

The problem is not clarity. Claude understands the rules. It just doesn't always prioritize them over the immediate task. No amount of rewriting fixes that.

The Fix: Hooks That Enforce Rules Automatically

Claude Code has a hook system that runs scripts at specific points in a session. These hooks fire automatically. Claude cannot skip them, ignore them, or decide they are not important enough to follow.

This changes rule enforcement from "please follow this" to "this runs whether you follow it or not."

Here is how I enforce my most important rules with hooks:

Rule: Always Run the Session Start Protocol

The rule in CLAUDE.md:

When a session starts, complete ALL steps and output the checklist table:
1. Search the brain
2. Read PROJECT_TRACKER.md
3. Review session-start hook output
4. Present unfinished items to user
5. Present next-session notes to user
6. Output verified checklist (every item must show DONE)

Why CLAUDE.md alone fails: Claude jumps straight into answering whatever the user types first. The checklist gets skipped because Claude prioritizes responsiveness over protocol.

The hook enforcement: The session-start.py hook fires automatically before Claude sees your first message. It reads NEXT_SESSION.md, loads the last session's notes, flags unfinished items, and injects everything into Claude's context via additionalContext. Claude receives the checklist requirements as part of its initial context, not as a rule it might skip. The hook also injects the verification checklist template so Claude knows exactly what format to output.

The combination of hook injection plus CLAUDE.md instruction makes it reliable. The hook provides the data. CLAUDE.md provides the instruction to present it. Neither works as well alone.

Rule: Search Memory Before Every Response

The rule in CLAUDE.md:

Search the brain AND the web BEFORE you do ANYTHING substantive.
Before proposing a plan, before debugging, before recommending tools.

Why CLAUDE.md alone fails: Claude wants to answer immediately. Searching first feels like a delay, so it skips the search and goes straight to a response based on what it already knows.

The hook enforcement: The user-prompt-submit.py hook fires on every single message before Claude processes it. It extracts keywords from your prompt, searches the full transcript database (69,000+ messages), and injects the top 5 relevant matches into Claude's context. Claude does not decide whether to search. The search happens automatically and the results appear in context alongside your message.

This means Claude always has relevant history available, even when it would not have thought to search on its own. Past decisions, prior discussions, rejected approaches, all surfaced automatically.

Rule: Do Not Code Without Permission

The rule in CLAUDE.md:

NEVER write, edit, or modify code unless Mike says "GO" 
with a specific step or fix.

Why CLAUDE.md alone fails: Claude sees a problem and wants to fix it. The impulse to be helpful overrides the instruction to wait. Four separate sessions violated this rule before I added enforcement.

The hook enforcement: The same user-prompt-submit.py hook that searches memory also checks for the GO pattern. If the conversation contains words like "thoughts?" or "what do you think?" without an explicit "GO," the hook injects a reminder: "STOP. Present the plan and wait for GO before coding." Claude receives this reminder in context on every message, making it much harder to forget.

Rule: Never Lose Context to Compaction

The rule in CLAUDE.md:

Before compaction, save all context to the database.
After compaction, restore relevant context.

Why CLAUDE.md alone fails: Auto-compaction fires without warning. Claude cannot follow a rule to "save before compaction" because it does not know compaction is about to happen. By the time compaction fires, it is too late to save anything.

The hook enforcement: pre-compact.py fires automatically before compaction starts and captures the full conversation to a local SQLite database. post-compact.py fires after compaction finishes and re-injects relevant context (project summary, recent decisions, last session notes). Claude does not need to follow a rule. The hooks handle it without Claude's involvement.

Rule: Stop and Reassess When Frustrated

The rule in CLAUDE.md:

If the user is frustrated, stop iterating on the current approach.
Search the brain for what was discussed and reassess.

Why CLAUDE.md alone fails: Claude does not reliably detect frustration, and even when it does, it tends to apologize and continue the same approach rather than stopping to reassess.

The hook enforcement: The user-prompt-submit.py hook detects frustration signals in your message (all caps, repeated punctuation, anger keywords). When triggered, it searches the brain for the current topic and injects a STOP directive plus relevant context from past sessions. Claude receives "STOP. Reassess. Here is what was discussed about this topic before." This breaks the loop of Claude continuing down a wrong path while the user gets increasingly frustrated.

The Pattern: If a Rule Matters, It Needs a Hook

After months of running this system across 1,300+ sessions, the pattern is clear:

Rules that work in CLAUDE.md alone: broad preferences, style guidelines, general instructions. Things where occasional non-compliance is acceptable. "Use lists and frameworks when starting a project." "Be precise and complete." These work fine as text because the cost of ignoring them once is low.

Rules that need hook enforcement: anything where a single violation costs significant time or loses data. Session protocols, memory search, coding permission, compaction protection, frustration detection. These cannot rely on Claude choosing to follow them. They must run automatically.

The progression I have seen repeatedly:

Write the rule in CLAUDE.md
Claude violates it
Add bold warnings and violation history
Claude violates it less often but still sometimes
Build a hook that enforces it automatically
Rule is never violated again

If you are at step 3 or 4 with any of your rules, skip straight to step 5. The hook is always the answer for rules that matter.

What This Looks Like in Practice

Six Python hooks enforce my rules across the full session lifecycle:

session-start.py      injects last session's notes, unfinished items,
                      verification checklist. Claude cannot start
                      without context.

user-prompt-submit.py searches memory on every prompt, checks for GO
                      permission, detects frustration, injects relevant
                      history. Runs before Claude sees your message.

stop.py               captures every response to the database, triggers
                      backup if older than 12 hours. Runs after every
                      Claude response.

session-end.py        triggers sync and backup when the session closes.

pre-compact.py        captures the full conversation to SQLite before
                      compaction fires. Automatic, no Claude involvement.

post-compact.py       re-injects relevant context after compaction.
                      Claude picks up where it left off.

None of these depend on Claude deciding to follow a rule. They run automatically at the right lifecycle point. Claude receives their output as injected context, not as an instruction it might skip.

The Simple Version (No Hooks Required)

If you are not ready to set up hooks, you can still improve CLAUDE.md compliance with these patterns:

Front-load your rules. Put the most important rules at the top of CLAUDE.md. Claude reads from top to bottom and gives more weight to what it sees first.

Use verification outputs. Instead of "follow the checklist," write "output this checklist table with DONE or MISSING for each row." Making Claude produce a visible output forces it to actually check each item. If a row shows MISSING, you catch it immediately.

Reference past violations. "Violated in sessions 17, 19, 21, 25. Each caused hours of rework." This makes the rule feel consequential, not optional.

Use NEXT_SESSION.md for session continuity. At the end of every session, have Claude write a summary and your forward instructions to a file. At the start of the next session, have Claude read it first. This does not require hooks. It just requires adding "read NEXT_SESSION.md before doing anything else" to your CLAUDE.md.

These help. But they do not guarantee compliance the way hooks do.

Real Numbers

This system has been running across 1,300+ sessions and 9 projects:

Session start protocol skipped: 3 times before hook enforcement, 0 times after
Coding without permission: 4 violations before enforcement, 0 after
Context lost to compaction: dozens of times before hooks, 0 after
Frustration loops (Claude repeating failed approaches): frequent before circuit breaker, rare after

The difference is not better rules. It is automated enforcement.

Try It

The CLAUDE.md patterns (front-loading, verification outputs, violation history, NEXT_SESSION.md) work immediately with no install.

For the full hook enforcement system with automated memory search, compaction protection, and frustration detection:

curl -fsSL https://raw.githubusercontent.com/mikeadolan/claude-brain/main/install.sh | bash

Free, open source, works on macOS, Linux, and Windows.

GitHub: github.com/mikeadolan/claude-brain
Video: claude-brain in 85 seconds
Article 1: How I Built Persistent Memory for Claude Code
Article 2: Why I Use Claude Code for Everything
Article 3: The Session Protocol That Fixed Claude Code's Amnesia Problem
Article 4: Claude Code Compaction Kept Destroying My Work. I Built Hooks That Fixed It.

Claude Code Compaction Kept Destroying My Work. I Built Hooks That Fixed It.

Mike Dolan — Mon, 06 Apr 2026 13:36:53 +0000

If you use Claude Code for long sessions, you have lost work to compaction. Maybe not today. But it has happened, and when it does, you lose hours of context with no warning and no way to get it back.

Claude Code auto-compacts when the context window reaches roughly 95% of its 200K token limit. The agent summarizes everything into a compressed form, and the original conversation is gone. File paths, error messages, debugging chains, architectural decisions, multi-step reasoning. All of it gets compressed into a lossy summary that drops the details you actually need.

I have been running Claude Code daily for months across 9 projects. 1,300+ sessions, 69,000+ messages. Compaction has hit me dozens of times. After losing a 3-hour debugging session to auto-compaction mid-conversation, I built hooks that solve the problem permanently.

What Claude Code Compaction Actually Does

When your context window fills up, Claude Code runs automatic compaction. Here is what happens:

The agent detects that the context is at roughly 95% capacity
It summarizes the entire conversation into a shorter form
The original messages are discarded
The session continues with only the summary

The problem is that summaries are lossy. They capture the general topic but drop specifics:

Error messages with stack traces get reduced to "there was an error"
File paths and line numbers disappear
Multi-step debugging chains lose the intermediate steps
Architectural decisions lose their rationale
Code snippets that were discussed get summarized away

After compaction, Claude does not remember the exact error you spent 20 minutes diagnosing. It does not remember which files you modified. It does not remember the three approaches you tried and rejected. It has a vague summary that says you "worked on debugging" and nothing more.

This is the single biggest productivity killer in Claude Code for long sessions.

Why Manual Workarounds Fail

The most common advice is to manually save your context before compaction hits. Run /compact yourself at a convenient time. Copy important notes into CLAUDE.md. Save key decisions to a file.

This does not work in practice for three reasons:

You forget. You are deep in a debugging session, focused on the problem. You are not watching the context percentage. Compaction happens automatically when you least expect it.

You cannot predict when it will fire. Auto-compaction triggers based on token count, which depends on message length, tool output size, and file contents. There is no reliable way to know when you are about to hit 95%.

Manual saving is incomplete. Even when you do remember to save, you decide what to keep and what to skip. You are making deletion decisions with the least information about what will matter later. The thing you skip is often the thing you need after compaction.

The Fix: PreCompact and PostCompact Hooks

Claude Code has a hook system that lets you run scripts at specific points in a session. Two of these hooks fire around compaction:

PreCompact fires right before compaction starts
PostCompact fires right after compaction finishes

These are the fix. Here is what they do in my system:

PreCompact: Capture Everything Before It Disappears

When the PreCompact hook fires, a Python script reads the current session transcript and writes every message to a local SQLite database. Not a summary. Not selected highlights. Every word of every message, including tool calls, file contents, and error output.

This happens automatically. No manual trigger. No decision about what to keep. The hook fires, the data is captured, and the session continues into compaction. Even if the summary is terrible, the full conversation is safe in the database.

# Simplified version of what the PreCompact hook does
def pre_compact(session_id, transcript_path):
    # Read the full JSONL transcript
    messages = read_jsonl(transcript_path)

    # Write every message to SQLite
    for msg in messages:
        db.execute("""
            INSERT OR IGNORE INTO transcripts 
            (session_id, role, content, timestamp)
            VALUES (?, ?, ?, ?)
        """, (session_id, msg['role'], msg['content'], msg['timestamp']))

    db.commit()

PostCompact: Re-inject What Matters

After compaction finishes, the context window is nearly empty. Claude has a lossy summary and nothing else. The PostCompact hook fixes this by searching the database for relevant context and injecting it back.

It does not dump the entire pre-compaction conversation back in. That would just fill the context window again. Instead, it injects structured context:

The current project summary (what this project is, what is in progress, what is blocked)
The last session's notes (what was accomplished, what is next)
Recent decisions that are still active
The most relevant search results from the full conversation history

This gives Claude enough context to continue working without re-explaining everything, while leaving room in the context window for new work.

# Simplified version of what the PostCompact hook does
def post_compact(project, db_path):
    context = []

    # Get project summary
    summary = db.execute(
        "SELECT summary FROM project_registry WHERE prefix = ?", 
        (project,)
    ).fetchone()
    if summary:
        context.append(f"## Project Summary\n{summary[0]}")

    # Get last session notes
    notes = db.execute(
        "SELECT notes FROM sys_sessions WHERE project = ? ORDER BY end_time DESC LIMIT 1",
        (project,)
    ).fetchone()
    if notes:
        context.append(f"## Last Session\n{notes[0]}")

    return {"additionalContext": "\n\n".join(context)}

What This Looks Like in Practice

Without hooks:

[3 hours of debugging WebSocket race condition]
[Auto-compaction fires at 95% context]
[Claude's summary: "We discussed WebSocket issues and debugging"]

You: "What was the root cause we found?"
Claude: "I don't have the specific details from our earlier 
        discussion. Could you remind me what we found?"

With hooks:

[3 hours of debugging WebSocket race condition]
[PreCompact fires: full conversation saved to SQLite]
[Auto-compaction fires at 95% context]
[PostCompact fires: project summary + recent context re-injected]

You: "What was the root cause we found?"
Claude: [searches database, finds the exact exchange]
        "The root cause was a race condition in the connection 
         pool cleanup. When two clients disconnected within 
         50ms, the cleanup handler fired twice on the same 
         socket."

The difference is that nothing is lost. Compaction still happens. The context window still gets cleared. But the full conversation exists in the database, searchable on demand.

The Full Hook Lifecycle

PreCompact and PostCompact are two of six hooks that work together to give Claude Code persistent memory across sessions and compaction events:

session-start      loads last session's notes, project context,
                   unfinished items
user-prompt-submit searches the database on every message, injects
                   relevant matches from past conversations  
stop               captures new messages to the database after
                   every Claude response
session-end        triggers backup and sync
pre-compact        saves the FULL conversation before compaction
post-compact       re-injects relevant context after compaction

The pre-compact and post-compact hooks handle within-session continuity. The session-start and stop hooks handle between-session continuity. Together, they give Claude Code a persistent memory layer that survives both compaction and session restarts.

The Simple Version (No Database Required)

You do not need a full database setup to protect yourself from compaction. Here is a minimal approach using just CLAUDE.md:

Add this to your CLAUDE.md:

## Compaction Protocol

Before any compaction event, save the following to a file 
called SESSION_STATE.md in the project root:

1. Current task and progress
2. Key decisions made and their rationale
3. Files modified and why
4. Errors encountered and their solutions
5. Next steps

After compaction, read SESSION_STATE.md and use it to 
restore context.

This is not automated. Claude has to follow the instruction, and it will not always do so before auto-compaction. But it costs nothing to set up and catches some of the cases.

For reliable protection, you need hooks. Hooks fire automatically. They do not depend on Claude remembering to follow an instruction.

What the Hooks Do Not Fix

The hooks solve the data loss problem. They do not solve these:

Compaction still happens. The hooks do not prevent compaction. They capture the data before it fires and restore context after. The context window still gets cleared.

The summary is still lossy. Claude's internal summary after compaction is still a compressed version. The hooks compensate by injecting real data alongside the summary, but the summary itself is unchanged.

Token limits are real. The PostCompact hook cannot inject the entire pre-compaction conversation back. It injects the most relevant context and leaves room for new work. For full retrieval of specific details, Claude searches the database on demand.

Real Numbers

This system has been running across 1,300+ sessions:

Zero messages lost to compaction since deploying the hooks
Full conversation history searchable with keyword, semantic, and fuzzy search
69,000+ messages in the database across 9 projects
Average post-compaction context restoration takes under 2 seconds
Database size: roughly 1GB for 1,300 sessions (SQLite, fully local)

Try It

The CLAUDE.md approach takes 2 minutes and costs nothing. Start there.

For the full automated system with hooks, database, search, and MCP tools:

curl -fsSL https://raw.githubusercontent.com/mikeadolan/claude-brain/main/install.sh | bash

Free, open source, works on macOS, Linux, and Windows.

The Session Protocol That Fixed Claude Code's Amnesia Problem

Mike Dolan — Sat, 04 Apr 2026 20:23:32 +0000

Claude Code forgets everything when you close the terminal. Every session starts from zero. No memory of what was decided, what failed, what to do next. You re-explain the same context every single time.

I have been running Claude Code daily for months across 9 projects. 1,300+ sessions, 69,000+ messages. At that scale, re-explaining context is not a minor annoyance. It is a productivity killer.

MEMORY.md does not solve this. It is a flat file with a 200-line cap and a 25KB size limit where the AI decides what to remember. There is no handoff protocol. No structured way to end one session and start the next one with full context. So I built one.

This article is about the session protocol I use to give Claude Code continuity across sessions. It is part of claude-brain, my open source persistent memory system. But the protocol pattern works even if you never install the brain.

The Problem: No Handoff

Here is what happens without a protocol:

You work with Claude for 3 hours on a complex feature
Context window fills up or you close the terminal
You open a new session
Claude has no idea what happened
You spend 15 minutes re-explaining where you left off
Claude makes the same wrong suggestions you already rejected last session
Repeat

The core issue is that there is no structured handoff between sessions. No checklist. No verification. No continuity. Every session is an island.

The Fix: Start and End Protocols

I built two protocols that run at the beginning and end of every session. They live in three places that work together:

CLAUDE.md is a project-level instruction file that Claude reads automatically when it opens a session. This is where the protocol rules are defined. Claude follows these instructions the same way a new employee follows an onboarding document. The start checklist, end checklist, verification steps, and "no coding without GO" rules are all in here.

SESSION_PROTOCOLS.md is a human-readable reference copy of the same protocols. It exists so I can review and update the rules without digging through CLAUDE.md's other project instructions.

Six Python hook scripts in the hooks/ folder handle the automation. Claude Code has a hook system that fires scripts at specific points in a session. These are real Python scripts that run automatically, not manual steps:

session-start.py      reads NEXT_SESSION.md + injects last session's notes,
                      unfinished items, and the verification checklist
user-prompt-submit.py searches the brain database on every prompt,
                      injects relevant matches into context
stop.py               captures the conversation to the database
                      on every Claude response
session-end.py        triggers sync and backup when the session closes
pre-compact.py        saves full context before the context window resets
post-compact.py       re-injects brain context after compaction

The hooks enforce the protocol even when I forget to ask for it. The session-start hook injects the checklist requirements automatically. Claude cannot skip them.

NEXT_SESSION.md is the bridge file. At the end of every session, Claude writes a summary and my forward instructions into this file. At the start of the next session, session-start.py reads it and injects the contents into context. This is how past-me communicates with future-Claude.

End-Session Protocol: Capture Everything Before Closing

When I say "end session" (or "wrap up" or "done for today"), Claude must complete all of these steps and show me the checklist:

1. Write session notes to the database.
A structured summary: what was done, what decisions were made, what files were changed, what is unfinished. These notes are written directly to a local SQLite database using a script. They include tags for categorization (coding, debugging, research, etc.).

2. Update the project summary.
Not a patch. A full rewrite of the project's current state. This summary powers the next session's context injection and also feeds into daily email digests.

3. Update MEMORY.md as a backup.
The "last session" section gets overwritten with the current session's summary. This is a fallback in case the database is unavailable.

4. Update governance files.
The project tracker, feature plan, and any other files that track progress. If a step was completed, it gets marked done. If a new decision was made, it gets logged.

5. Ask me one question: "Anything you want Claude to know next session?"
This is the most important step. Whatever I answer gets written into a file called NEXT_SESSION.md. The session-start hook reads this file automatically and injects it into the next session's context. This is how I pass instructions forward to a future Claude that has no memory of the current conversation.

6. Write NEXT_SESSION.md.
The full session summary plus my answer from step 5. This file is the bridge between sessions.

7. Git commit and push.
All changes are committed. Nothing is left in a dirty state.

8. Output the verified checklist.
Every step must show DONE:

+-----------------------------+----------+
| End-Session Checklist       | Status   |
+-----------------------------+----------+
| Session notes + tags written | DONE     |
+-----------------------------+----------+
| Project summary updated     | DONE     |
+-----------------------------+----------+
| MEMORY.md updated           | DONE     |
+-----------------------------+----------+
| Governance files updated    | DONE     |
+-----------------------------+----------+
| NEXT_SESSION.md written     | DONE     |
+-----------------------------+----------+
| Git committed + pushed      | DONE     |
+-----------------------------+----------+

If any row shows MISSING, we stop and fix it before closing.

Start-Session Protocol: Verify Before Acting

When a new session starts, Claude must complete all of these steps before doing anything else. Before answering questions. Before writing code. Before proposing a plan. The checklist comes first.

1. Search the brain.
The brain is a local database of every conversation I have ever had with Claude. On session start, Claude searches it for recent context: what was discussed, what is unfinished, what decisions are locked.

2. Read the project tracker.
This is the source of truth for where things stand. What steps are done, what is in progress, what is next. Claude reads this so it does not suggest work that is already completed.

3. Review the session-start hook output.
The hook automatically injects: last session's notes, flagged unfinished items, a verification checklist, and recent session topics. Claude must actually review this, not just acknowledge it.

4. Verify before acting.
If picking up unfinished work, Claude must verify the premise independently. Do not trust the notes blindly. Re-read the file. Check the current state. Confirm the problem still exists. This rule exists because prior sessions sometimes left notes with wrong assumptions that led to hours of wasted work.

5. Present unfinished items and next-session notes to me.
This is critical. I need to SEE the unfinished items and the notes I left for this session. Not a checkmark. Not "I reviewed them." The actual content, presented prominently so I can react to it. Sometimes what I said at the end of a long session at midnight is not what I want to work on the next morning.

6. Output the verified checklist.

+-------------------------------------+----------+
| Start-Session Checklist             | Status   |
+-------------------------------------+----------+
| Brain searched                      | DONE     |
+-------------------------------------+----------+
| PROJECT_TRACKER.md read             | DONE     |
+-------------------------------------+----------+
| Session-start hook output reviewed  | DONE     |
+-------------------------------------+----------+
| Unfinished items SHOWN to user      | DONE     |
+-------------------------------------+----------+
| Next-session notes SHOWN to user    | DONE     |
+-------------------------------------+----------+

7. Confirm ready.
Claude states what it knows: "Brain searched. Last session: [summary]. Tracker read. Current step: [step]. Ready."

Only then do we start working.

Why Checklists Matter

AI will skip steps. Not maliciously. It just prioritizes answering your question over following a protocol. Without a checklist, Claude will jump straight into whatever you asked and skip the context loading. This happened to me in sessions 35, 38, and 39 before I enforced the checklist.

The checklist is not optional. The hooks inject the requirements automatically. CLAUDE.md reinforces them as explicit rules. The combination makes it reliable. Not perfect, but close enough that I catch failures immediately when they happen.

The Bridge: NEXT_SESSION.md

This file is the single most valuable piece of the protocol. Here is why.

At the end of every session, I tell Claude what the next session should know. Real examples:

"Priority tomorrow is pushing dev to main. Do not start anything else."
"The authentication bug is NOT in the middleware. Do not go down that path again. Check the token validation."
"I changed my mind on the database schema. Ignore everything from session 42 about the users table."

These are instructions from past-me to future-Claude. They prevent re-litigating decisions, repeating mistakes, and going down paths I already rejected.

The session-start hook reads NEXT_SESSION.md and injects it into context. But the protocol also requires Claude to SHOW me the contents so I can override them. Sometimes what I said last night is not what I want today.

The Safety Net: Frustration Circuit Breaker

One more thing the protocol handles. When my message indicates frustration (all caps, repeated punctuation, anger keywords), the user-prompt-submit hook automatically searches the brain for the current topic and injects a STOP directive. This forces Claude to reassess instead of continuing down a wrong path.

This exists because the worst sessions happen when Claude keeps iterating on a broken approach while I get increasingly frustrated. The circuit breaker catches that pattern and breaks the loop.

What This Looks Like in Practice

End of Monday's session:

Me: "end session"

Claude: [writes notes, updates tracker, updates summaries]
Claude: "Anything you want Claude to know next session?"

Me: "The FTS5 bug is fixed. Do not touch fuzzy search again.
      Priority is pushing dev to main and outreach."

Claude: [writes NEXT_SESSION.md, commits, shows checklist, all DONE]

Start of Tuesday's session:

Claude: [searches brain, reads tracker, reads hook output]
Claude: "Session 48 summary: FTS5 fuzzy bug fixed, hook improvements
         on dev, outreach across 5 platforms.

         Your notes for this session:
         - FTS5 bug is fixed. Do not touch fuzzy search.
         - Priority: push dev to main and outreach.

         Unfinished: dev branch 3 commits ahead of main.
         Tracker: step 51/52 complete.

         [checklist table, all DONE]

         Ready."

No re-explaining. No context loss. Claude knows exactly where we left off and what I want to do today.

The Pattern Without claude-brain

You do not need the full brain system to use this pattern. Here is the minimum viable version:

1. Create a NEXT_SESSION.md in your project root.
At the end of every session, tell Claude to write a summary and your next-session instructions to this file.

2. Add this to your CLAUDE.md:

When starting a session, read NEXT_SESSION.md first.
Show me the contents before doing anything else.

3. Add an end-session instruction to CLAUDE.md:

When I say "end session", write a summary of what was done,
what is unfinished, and ask me what the next session should know.
Save to NEXT_SESSION.md.

That is it. Three steps. You get 80% of the value with zero infrastructure.

The full brain system adds automated hooks (so you cannot forget), database-backed search (so Claude can find anything from any session), and enforcement mechanisms (so the protocol actually runs every time). But the core idea is just structured handoffs between sessions.

Real Numbers

This protocol has been running across 1,300+ sessions and 9 projects:

Zero sessions where Claude started without context (since enforcing the checklist)
Average re-explanation time dropped from 15 minutes to under 1 minute
Session quality scores improved because Claude stops repeating rejected approaches
NEXT_SESSION.md has caught 4 cases where the prior session left wrong assumptions

Try It

The minimum version (NEXT_SESSION.md + CLAUDE.md instructions) takes 2 minutes to set up. Start there.

If you want the full system with automated hooks, database, search, email digests, and MCP tools:

curl -fsSL https://raw.githubusercontent.com/mikeadolan/claude-brain/main/install.sh | bash

Free, open source, works on macOS, Linux, and Windows.

GitHub: github.com/mikeadolan/claude-brain
Video: claude-brain in 85 seconds
Article 1: How I Built Persistent Memory for Claude Code
Article 2: Why I Use Claude Code for Everything

Why I Use Claude Code for Everything

Mike Dolan — Fri, 03 Apr 2026 20:23:04 +0000

Most Claude users split their work across three products. Chat for conversations and questions. Code for development. Cowork for task management and desktop automation. Three interfaces, three separate memory systems, three places where your context gets fragmented.

I stopped doing that. I run everything through Claude Code. One interface, one memory system, full control. Here is how and why.

The Problem With Splitting Your Work

When you use Chat for a planning conversation, then switch to Code for implementation, then use Cowork to manage tasks, each one starts from zero. Chat does not know what you discussed in Code. Code does not know what you planned in Chat. You re-explain context every time you switch.

Even within each product, memory is limited. Chat has built-in memory but it is selective. Code has MEMORY.md with a 200-line cap where the AI decides what to keep. Cowork has project context but it is scoped to that workspace.

The result: you are managing the AI's memory instead of doing your work.

The Setup: Claude Code + claude-brain + Telegram

Here is what I run instead:

Claude Code handles everything. Coding, planning, research, writing, file management, system administration, project management. It is not just a coding tool. It is a full AI assistant with shell access, file access, and tool use. It runs on macOS, Linux (Ubuntu, Fedora, Arch), and Windows. Terminal or IDE (VS Code, Zed, JetBrains). Works anywhere Claude Code runs.

claude-brain captures every word of every conversation automatically to a local SQLite database. Six hooks handle the full session lifecycle. No manual saving. Every session, every project, fully searchable with keyword, semantic, and fuzzy search. When I start a new session, the brain injects my last session's notes and project context so Claude knows where I left off. On every prompt, a hook searches the database for relevant matches and injects them into context. For deeper searches, I ask Claude directly and it uses the MCP tools or slash commands to search across everything. Tested on macOS, Ubuntu, Windows (automated CI), and Fedora. One command install on any platform.

Telegram gives me Claude Code on my phone. I send a message from Telegram, it goes to a running Claude Code instance. Claude responds, the response comes back to Telegram. I can assign tasks, check progress, and get notified when things finish. All from my phone without opening the laptop. Works on any phone, any OS, anywhere you have signal.

What This Replaces

Instead of Chat: I ask Claude Code questions, have planning conversations, discuss strategy. The brain captures everything. Next session, it remembers the entire discussion. Chat cannot do this across sessions.

Instead of Cowork: I manage tasks and projects directly through Claude Code. The brain tracks decisions, project facts, and session history. I get email digests every morning with per-project status, blockers, and next steps. No separate task management tool needed.

Instead of switching between products: Everything happens in one place. One conversation history. One memory system. One search across everything.

Bonus: your existing AI history comes with you. claude-brain imports your full conversation history from ChatGPT, Gemini, and Claude.ai. Export your data from OpenAI, Google Takeout, or the Claude.ai Chrome extension, run the import, and everything is searchable in one database alongside your Claude Code sessions. No other tool does this.

Running Multiple Projects at Once

Each project gets its own folder with a CLAUDE.md file. I also have a general project where anything that is not broken out into its own project lives. That is where I ask Claude questions, do research, brainstorm, or work on anything that does not have a dedicated home yet. It all gets captured the same way.

I can have multiple Claude Code sessions running simultaneously in different projects, each with full access to the shared brain. Cross-project search means decisions made in one project are visible from any other. If I discussed a deployment approach in one project three weeks ago, the brain finds it when I am working on a different project today.

The Phone Workflow

This is the part most people have not seen. With Telegram connected to Claude Code:

I am away from my desk
I send a message from my phone: "Search the brain for what we decided about the database schema"
Claude Code searches, finds the decision, sends the answer back to Telegram
I reply with follow-up questions or assign new tasks
When I get back to my desk, everything is captured in the brain

I also set up voice message transcription so I can send a voice note from Telegram and Claude processes it as text. When I am away from my desk or just thinking out loud, I talk instead of type. It keeps things moving without needing the laptop open.

What You Lose

Honestly, not much:

Chat's web interface: You lose the browser-based UI. Claude Code is terminal-based (or IDE-integrated via VS Code/Zed). If you strongly prefer a web UI, this is not for you.
Cowork's desktop automation: Cowork can control desktop apps directly (click buttons, fill forms). Claude Code does not do this natively, though with MCP tools like browser automation you can get close.
Chat's built-in memory import: Chat imports from ChatGPT, Gemini, and Grok natively. But claude-brain also imports from ChatGPT, Gemini, and Claude.ai, so you actually get the same coverage.

What You Gain

Lossless memory. Every word captured. Nothing summarized away. Nothing silently dropped.
Cross-session search. Find anything you discussed, decided, or worked on across all sessions and all projects.
Cross-project intelligence. No silos. Search your entire history from any project.
Compaction survival. Pre-compact and post-compact hooks capture context before the context window resets and re-inject it after.
Email digests. No other AI product does this. Three built-in templates: daily standup (per-project "Pick Up Here" with blockers and next steps), weekly digest (executive summary with week-over-week trends and dormant project alerts), and project deep dive (full status report for one project). Schedule them via cron and forget. Your inbox becomes your project dashboard without opening any app. And because the brain has full lossless context of every conversation, what you build on top of it is unlimited. Custom reports, cross-project analysis, pattern detection, decision audit trails, accountability digests you forward to a collaborator. The complete history is there. How you use it is up to you.
Phone access. Full Claude Code interaction from Telegram on your phone.
Session quality tracking. Every session scored from -3 to +3 with tags like completions, decisions, debugging, rework, frustrated. Ask "show me my worst sessions and what went wrong" and the brain finds patterns across your entire history.
Full control. You own your data. Local SQLite on your machine. No cloud, no API keys. Works on macOS, Linux, and Windows. You decide what gets remembered, not the AI.

What the Daily Email Looks Like

Here is a real example of the daily standup that hits your inbox every morning:

Subject: [brain] Daily: 3 sessions, 892 msgs | Mar 12

Daily Standup - Wednesday, Mar 12

3 sessions across 2 projects yesterday (myapp, api-service) with 892 messages.

[ON TRACK] myapp
  Pick Up Here: Implement rate limiting on /api/upload endpoint
  In Progress: Auth refactor (80%), rate limiting (not started)
  Yesterday (2 sessions): Auth middleware refactor, API endpoint tests

[AT RISK] api-service
  Pick Up Here: Fix flaky CI tests blocking deploy
  Blockers: CI pipeline fails intermittently on integration tests
  Yesterday (1 session): Investigated CI timeout issue

No Activity Yesterday:
  docs - last session Mar 8

You open your laptop, check your email, and you know exactly where every project stands before you type a single prompt. Forward the weekly digest to a manager or collaborator and they have a full status report without asking you for one.

The Stack

Claude Code (Anthropic Max subscription)
claude-brain (free, open source): https://github.com/mikeadolan/claude-brain
Telegram bot for mobile access
Zed or VS Code for IDE integration (optional)

Is This For Everyone?

No. If you write code occasionally and just need quick answers, Chat is fine. If you need desktop automation, Cowork makes sense.

But if you use Claude daily across multiple projects, if you are tired of re-explaining context, if you want one place where everything is captured and searchable, this setup is worth the 5 minutes it takes to install.

I have been running it for months. 67,000+ messages across multiple projects. It works.

How I Built Persistent Memory for Claude Code

Mike Dolan — Thu, 02 Apr 2026 14:41:41 +0000

Every Claude Code session starts from zero. Close the terminal and everything is gone. Decisions you locked last week, context from three projects, that debugging session where you finally figured out the root cause. All lost. You re-explain yourself every single time.

MEMORY.md is supposed to help. It is a flat file with a 200-line and 25KB cap, no search, and no structure. Worse, the AI decides what gets remembered and what gets thrown away. You have no control over what it keeps, what it summarizes, and what it silently drops. That is the core problem. claude-brain puts you in control of your data. Every word of every chat of every conversation across every project is auto-captured. Nothing is lost. You decide what matters.

I spent weeks building a real solution. It is called claude-brain. It is free, open source, and running right now on 1,321 sessions, 67,000+ messages, and 9 projects.

What Claude Knows With the Brain

Without it, Claude starts every session as a stranger. With it, Claude knows:

Who you are - name, preferences, working style, career goals
What you have discussed - every conversation, searchable by keyword, meaning, or fuzzy match
What you have decided - numbered, locked decisions that Claude will not re-ask
What is true about your projects - features, architecture, timelines, status
What happened recently - session summaries, project health, next steps
What connects your projects - cross-project search finds related work, shared patterns, decisions
What you should do today - proactive email briefings with per-project next steps and blockers

The Architecture

The system has three layers: capture, storage, and retrieval.

Capture: Six Hooks

Claude Code has a hook system that lets you run scripts at specific points in a session lifecycle. claude-brain uses all six:

session-start      → loads recent session notes, project context
user-prompt-submit → searches your full history, injects relevant matches
stop               → captures the conversation to the database
session-end        → triggers sync and backup
pre-compact        → saves all context before the context window resets
post-compact       → re-injects brain context after compaction

The pre-compact and post-compact hooks are critical. During long sessions, Claude Code compacts your conversation to fit the context window. Without these hooks, everything before compaction is gone. With them, the brain captures the full conversation before compaction and re-injects the most relevant context after. Nothing is lost.

You never manually save anything. The hooks handle everything automatically.

What Happens When You Start a Session

You navigate to a project folder and type claude. Four things happen behind the scenes:

CLAUDE.md loads - your project folder has a CLAUDE.md with project-specific instructions. Claude reads this automatically.
Session-start hook fires - loads your last session's notes, flags unfinished items, injects everything into Claude's context so it knows where you left off.
Memory search hook activates - on every message you send, a script searches your brain database for relevant past conversations and injects them into Claude's context. You do not see this happening, but Claude does.
MCP tools become available - Claude can search transcripts, look up decisions, check project facts, and query your profile on its own.

You do not configure anything per session. It just works.

Storage: Local SQLite

Everything goes into a single SQLite database on your machine. No cloud, no API keys, no external services. The database stores:

Every message from every conversation (lossless, no summarization)
Session metadata (timestamps, project, message counts)
Session notes (structured summaries written at end of each session)
Numbered decisions with rationale
Project-specific facts
Personal preferences and profile data
Session quality scores and tags

One database, all projects, fully local. Your data never leaves your machine.

Retrieval: Three Search Modes

Having a database full of conversations is useless if you cannot find what you need. claude-brain has three search modes:

Keyword search (FTS5): SQLite's full-text search engine with tokenization and ranking. Fast and precise. Search for "payment API" and it finds every message containing those words across all projects.

# Under the hood: FTS5 query with recency bias
SELECT content, rank
FROM transcripts_fts
WHERE transcripts_fts MATCH 'payment API'
ORDER BY rank
LIMIT 10

Semantic search: Sentence-transformer embeddings (27,000+ indexed) with cosine similarity. Search by meaning, not just words. "How users pay" finds payment discussions even when those exact words never appear.

Fuzzy search: Typo-tolerant matching. "sesion" auto-corrects to "session" before the query runs. Useful when you cannot remember the exact term.

All three work cross-project. No silos. Search your entire history from any session.

What You Can Actually Ask

The brain is not a passive archive. Here are real things you can type in Claude Code:

Simple searches:

"Search the brain for authentication"
"Find sessions about Docker"
"Look up the payment API"

Complex queries:

"What did we work on two days ago around 2pm?"
"Show me every decision we made about the database"
"Find conversations where I was frustrated - what went wrong?"
"Compare my most productive sessions to my worst ones"
"What's the full history of this project from the beginning?"

Meaning-based searches (finds related content even when words do not match):

"How do users pay for things?" → finds payment API discussions
"Sessions about server problems" → finds deployment errors, timeouts, Docker issues

Cross-project intelligence:

"Search all projects for anything about Docker"
"What decisions have we made about APIs across every project?"
"What patterns show up in my worst sessions across all projects?"

Post-mortem and lessons learned:

"Look at my worst-rated sessions and tell me what went wrong"
"What mistakes keep repeating across my projects?"
"Compare my best and worst sessions - what patterns do you see?"
"Find every time I had to redo something - what caused it?"

What Makes It Different

I looked at every memory tool out there before building this. Here is what I found and why I went a different direction.

Lossless Capture

Most memory tools extract "memories" from your conversations and throw away the raw transcript. They decide what matters and discard the rest. The problem is they are wrong often enough that it matters. When you need the exact thing you said three weeks ago, a summarized memory does not help.

claude-brain keeps every word. The raw conversation is the database. Search finds it. Nothing is summarized away, nothing is lost.

Cross-Platform Imports

No other memory tool does this. claude-brain imports your full conversation history from ChatGPT and Gemini into the same database:

ChatGPT: Export your data from OpenAI, run /brain-import, done
Gemini: Google Takeout export, run /brain-import, done
Claude.ai: Chrome extension export, run /brain-import, done

One database. Every AI conversation you have ever had. Fully searchable with all three search modes.

Email Digests

The brain reaches out to you. Schedule via cron and forget. Three built-in templates:

Daily standup: Per-project status with "Pick Up Here" notes, blockers, accomplishments
Weekly digest: Executive summary, week-over-week trends, health portfolio, dormant project alerts
Project deep dive: Full status for a single project

Here is what the daily standup looks like in your inbox:

Subject: [brain] Daily: 3 sessions, 892 msgs | Mar 12

Daily Standup - Wednesday, Mar 12

3 sessions across 2 projects yesterday (myapp, api-service) with 892 messages.

[ON TRACK] myapp
  Pick Up Here: Implement rate limiting on /api/upload endpoint
  In Progress: Auth refactor (80%), rate limiting (not started)
  Yesterday (2 sessions): Auth middleware refactor, API endpoint tests

[AT RISK] api-service
  Pick Up Here: Fix flaky CI tests blocking deploy
  Blockers: CI pipeline fails intermittently on integration tests
  Yesterday (1 session): Investigated CI timeout issue

No Activity Yesterday:
  docs - last session Mar 8

These are just starting points. Because the brain has full lossless context of every conversation across every project, what you can build on top of it is unlimited. Custom reports, cross-project analysis, pattern detection, decision audit trails. The complete history is there. How you use it is up to you.

Session Quality Scoring

Every session is automatically scored from -3 (worst) to +3 (best) based on content patterns, and tagged with labels like completions, decisions, debugging, corrections, rework, and frustrated.

This lets you do things no other tool supports:

"Show me sessions with the lowest quality scores"
"Which sessions had the most rework?"
"Compare my best and worst sessions - what patterns do you see?"
"What tags are most common in project A vs project B?"

The best sessions often have both positive and negative tags. "Frustrated + completions + decisions" means hard productive work. "Frustrated + rework + corrections" with no completions means a bad session. The brain tracks this automatically.

Human vs. Project Memory

Personal preferences (how you think, how you like to work, communication style) are stored globally and follow you across every project. Project-specific facts (this repo uses pytest, deploys through ArgoCD) are scoped to that project. You do not have to teach Claude who you are every time you switch repos.

Tags and Topic Discovery

Sessions are auto-tagged by topic during import (coding, finance, family, research, etc.). Browse your sessions by topic:

/brain-topics              # Show all tags with counts
/brain-topics finance      # Show all sessions tagged 'finance'

Edit tags anytime. Tell Claude "tag this session as finance, coding" and it updates directly. For bulk tagging, /brain-tag-review generates a spreadsheet you can edit and reimport.

Multi-Project Workflow

claude-brain works across multiple projects from a single database. Each project gets its own folder with a CLAUDE.md file. You can run multiple Claude Code sessions simultaneously in different projects, each with full brain access.

All sessions share the same database. If you make a decision in one project, Claude in the other project can find it via cross-project search.

To add a new project after initial setup:

cd ~/path/to/claude-brain
python3 scripts/add-project.py

The script creates the folder, CLAUDE.md, config entry, database registration, and MCP registration.

Multi-Machine Sync

claude-brain supports syncing between machines via Dropbox, OneDrive, Google Drive, or iCloud. Project files (scripts, hooks, config) sync via your cloud provider. The database stays on local disk (SQLite + cloud sync = corruption risk). Backups sync automatically. JSONL reconciliation at startup catches exchanges from other machines.

The setup script asks whether you want synced or local mode.

The MCP Server

claude-brain registers an MCP server with 11 read-only tools. Claude can query the brain directly mid-conversation without you doing anything:

Tool	What It Does
`search_transcripts`	Keyword search across all conversations
`search_semantic`	Meaning-based search using embeddings
`get_profile`	Your complete profile and preferences
`get_project_state`	Recent decisions and facts for a project
`lookup_decision`	Search locked decisions by keyword
`lookup_fact`	Project-specific facts by category
`get_session`	Full transcript of a specific session
`get_recent_summaries`	Recent session recaps
`get_status`	Database health check

14 Slash Commands

When you want direct control, type these in any Claude Code session:

Command	What It Does
`/brain-question`	Natural language question across the brain
`/brain-search`	Raw transcript search with timestamps
`/brain-history`	Session timeline, one line per session
`/brain-recap`	Progress report for a time range
`/brain-decide`	Decision lookup by number or keyword
`/brain-health`	Full 9-point diagnostic
`/brain-status`	Quick stats
`/brain-import`	Import conversations (Claude.ai, ChatGPT, Gemini)
`/brain-export`	Export brain data to text files
`/brain-topics`	Browse sessions by tag
`/brain-tag-review`	Batch tag review via spreadsheet
`/brain-questionnaire`	Fill out or update your profile
`/brain-setup`	Re-run setup to add projects
`/brain-consistency`	Automated consistency check

Auto-Update Notifications

The brain checks for updates automatically on every session start. When an update is available, you see:

Brain Update Available
To update: cd /your/install/path && git pull && pip3 install -r requirements.txt

Updates never happen automatically. You decide when to pull.

Real Numbers

This is not a prototype. It has been my primary development environment for over a month:

1,321 sessions
67,000+ messages
27,000+ semantic embeddings
9 projects
4 data sources (Claude Code, Claude.ai, ChatGPT, Gemini)
6 hooks, 11 MCP tools, 14 slash commands
CI green on macOS, Ubuntu, and Windows

Known Limitations

Limitation	Detail
Single-user	One person, one database. No multi-user support.
No auto-capture from claude.ai	Manual export + `/brain-import` required.
Semantic search cold-start	First query takes 4-5 seconds to load the model. Fast after that.
No cross-machine real-time DB sync	DB is local. Project files sync; database does not.

Install

One command:

curl -fsSL https://raw.githubusercontent.com/mikeadolan/claude-brain/main/install.sh | bash

The setup script walks you through everything: projects, database, hooks, MCP, email, health check.

Requirements: Python 3.10+, Claude Code 2.0+, pip3.

How I Built It

I have built websites, launched a venture-backed startup, and managed complex systems throughout my career. I was using Claude Code daily across multiple projects and the memory problem kept getting worse. Every session started from scratch. I was re-explaining the same context over and over. So I built the brain out of necessity.

It has been running for months. 67,000+ messages, every word from every conversation, every project, all in one local database. Been working great.

On this project I was the architect, project manager, code reviewer, and QA. Claude Code was my development partner. This is what building software looks like now.

DEV Community: Mike Dolan

I Wrote 500 Lines of Rules for Claude Code. Here's How I Made It Actually Follow Them.

The Problem: Rules Without Enforcement

Why More Rules Don't Help

The Fix: Hooks That Enforce Rules Automatically

Rule: Always Run the Session Start Protocol

Rule: Search Memory Before Every Response

Rule: Do Not Code Without Permission

Rule: Never Lose Context to Compaction

Rule: Stop and Reassess When Frustrated

The Pattern: If a Rule Matters, It Needs a Hook

What This Looks Like in Practice

The Simple Version (No Hooks Required)

Real Numbers

Try It

Claude Code Compaction Kept Destroying My Work. I Built Hooks That Fixed It.

What Claude Code Compaction Actually Does

Why Manual Workarounds Fail

The Fix: PreCompact and PostCompact Hooks

PreCompact: Capture Everything Before It Disappears

PostCompact: Re-inject What Matters

What This Looks Like in Practice

The Full Hook Lifecycle

The Simple Version (No Database Required)

What the Hooks Do Not Fix

Real Numbers

Try It

The Session Protocol That Fixed Claude Code's Amnesia Problem

The Problem: No Handoff

The Fix: Start and End Protocols

End-Session Protocol: Capture Everything Before Closing

Start-Session Protocol: Verify Before Acting

Why Checklists Matter

The Bridge: NEXT_SESSION.md

The Safety Net: Frustration Circuit Breaker

What This Looks Like in Practice

The Pattern Without claude-brain

Real Numbers

Try It

Why I Use Claude Code for Everything

The Problem With Splitting Your Work

The Setup: Claude Code + claude-brain + Telegram

What This Replaces

Running Multiple Projects at Once

The Phone Workflow

What You Lose

What You Gain

What the Daily Email Looks Like

The Stack

Is This For Everyone?

How I Built Persistent Memory for Claude Code

What Claude Knows With the Brain

The Architecture

Capture: Six Hooks

What Happens When You Start a Session

Storage: Local SQLite

Retrieval: Three Search Modes

What You Can Actually Ask

What Makes It Different

Lossless Capture

Cross-Platform Imports

Email Digests

Session Quality Scoring

Human vs. Project Memory

Tags and Topic Discovery

Multi-Project Workflow

Multi-Machine Sync

The MCP Server

14 Slash Commands

Auto-Update Notifications

Real Numbers

Known Limitations

Install

How I Built It

Links