I compared four Claude Code memory tools, and why I still keep a Second Brain

TL;DR

• Four memory tools for AI coding agents, compared on where memory lives, what it costs in tokens, how hard each is to set up and change, and how stale entries get caught. gstack and Superpowers teach the AI how to work, claude-mem records what happened, ECC stores memory files and treats them as unreviewed.
• A Second Brain answers a fifth way: it keeps what is true about your project right now, with a date on every fact. The free Second Brain Starter has the files to copy.

I write Code Meet AI, the newsletter where I document how I actually use AI to ship real products, receipts included. New guides land there first.

Last time, in How to build a Second Brain that stays useful, I built one from five records and a fresh-session test. Four memory tools for coding agents keep showing up on builders' feeds. Here they are side by side, and next to it.

Four ways to compare memory tools

A new AI session starts empty. Everything it knows about your project comes from what gets loaded in the first seconds.

Developers gave the AI a memory by hand long before these four existed. The best-known version was the Memory Bank: a folder of structured Markdown files that the assistant reads at the start of a session and updates as it works. Cline's documentation describes it that way. I wrote about it for Cursor in How to Enhance Cursor AI Memory Bank and about the habit itself in Give the AI a memory.

Three things made it spread:

• No tooling. The memory is ordinary Markdown files, so any assistant that can read a file can use it.

• Visible. You open a file and see what the AI knows about the project.

• Editable and versioned. The files live in the repo, so you correct a wrong line by hand and git keeps the history.

Memory handling is more than the start of a session. The tools below are compared on where the memory lives, what loads at the start and what waits until it is asked for, what it costs in tokens, and how a wrong or old entry gets found.

gstack: a team of roles

gstack is Garry Tan's open-source pack of Markdown slash commands. Each command turns Claude Code into one member of a small team: a CEO who challenges the plan, a designer, an engineering manager, a QA tester, a release engineer.

It has about 137,000 stars and an MIT license.

You install it by cloning the repo into ~/.claude/skills/gstack and running ./setup. It needs Bun.

Memory

• /learn. Lets you review, search and prune what gstack picked up about your codebase.

• Design taste. A profile of what you approve and reject that fades by 5% a week.

• GBrain. An optional add-on with a separate knowledge base, which the README calls the memory your agent keeps between sessions.

Superpowers: a method the AI follows

Superpowers is a skills framework and a development method by Jesse Vincent and the Prime Radiant team. It has about 304,000 stars and an MIT license.

On Claude Code you add it with /plugin install superpowers@claude-plugins-official.

Its skills trigger on their own. Before a task, the agent checks whether a skill applies: brainstorming before building, a plan before code, a review before done.

Memory

• Session start. A short startup skill, called the bootstrap, is loaded at the start of each session so the agent knows the other skills exist.

• Store. The README describes no memory store. What Superpowers carries from session to session is a way of working.

claude-mem: record everything, replay what matters

claude-mem is Alex Newman's plugin. It has about 103,000 stars and an Apache-2.0 license.

Install is npx claude-mem install. The installer asks you to sign in.

The README says sign-in unlocks a 30-day free trial of its hosted memory provider, and afterwards memory runs on your Anthropic plan unless you subscribe or bring your own key.

Memory

• Capture. Hooks fire at six moments in a session: start, prompt, before a tool, after a tool, stop and end. They send what the agent did to a small local service.

• Storage. The service compresses it with AI and stores it in SQLite, with a vector index for search (a database index that finds notes by meaning as well as by keyword). A <private> tag keeps a passage out of storage.

• Replay. At the next session start, relevant past context is put back in.

ECC: memory as unreviewed files

Everything Claude Code, now at affaan-m/ECC, is Affaan Mustafa's bundle of skills, rules, hooks and memory for Claude Code, Codex and others.

It has about 288,000 stars and an MIT license.

Install is npx ecc-universal@2.2.3 setup, the pinned form the README gives, or through the plugin marketplace.

Memory

• Where it lives. A Memory Vault stores plain Markdown documents, in .ecc/memory/ for a project and ~/.ecc/memory/ for you.

• Session hooks. A session-start hook loads context and a session-end hook saves it. A small set of learned patterns, called instincts, is injected at the start up to a cap.

• Trust. The README calls memory unreviewed context, and it says a human promotes accepted knowledge into the project's own documents.

What a Second Brain does differently

This part is my approach. Here is how I read the gap each setup leaves:

• gstack. The roles are the center of its pitch and memory is the smaller part. If the AI plans without being challenged, the roles are aimed at that.

• Superpowers. It teaches the AI how to build. Your project's facts still have to come from somewhere else.

• claude-mem. Say you spent Monday moving a login flow from one Supabase project to another. By Thursday it can hand the new session a summary of Monday, which is a strong answer to forgetting. The summary is a history written by a model, so if Monday's plan changed on Tuesday, the history holds both and the new session has to work out which one is current.

• ECC. Someone has to decide which saved note is true, and it leaves that step to you.

A Second Brain keeps current facts in plain files you own, and it makes the review step part of the system instead of leaving it open.

The shape from Article 2 is five records per project. Rules name the route the AI follows. A facts file holds current values, each with a checked date. A decisions file holds one line per choice with its reason. A roadmap holds open work with evidence. A progress log ends with a Next line.

The AI reads rules and facts first and the rest on demand. I run a fresh-session test to prove it recovers a decision from the files alone.

At the last count, on 22 October 2026, my own vault had 645 memory files, 119 skills, 41 commands and 640 session reports. It stays usable because the project records are small, dated and reviewed weekly.

The four answers side by side

Setup	Where memory lives	Loads at session start	How a stale entry gets caught
gstack	Per-project learnings, optional gbrain knowledge base	Roles load when you call them	/learn lets you review and prune
Superpowers	No memory store in the README	A bootstrap skill, then skills as tasks need them	Not a memory feature
claude-mem	SQLite plus a vector index, local service	Relevant past context, injected by hooks	No stale-entry check; <private> only keeps passages out of storage
ECC	Markdown files in .ecc/memory/	Hook-loaded context and a capped set of instincts	You review and promote into project docs
Second Brain	Five Markdown records per project	Rules and facts first	Checked date on every fact, weekly review

The last column is the one I weigh most, because an old entry read with confidence is the failure that costs me the most time. Each of the four rows solves a different problem.

Tokens and answer quality

Each setup spends tokens in a different place. What follows is what the READMEs say about their own design. Measured token use and answer quality are a separate test.

• gstack. It ships gstack-context-bill, a read-only audit of what an installed skills tree costs in tokens: the always-on frontmatter every session pays, against the skill text that loads when you call one.

• Superpowers. The startup bootstrap loads each session and skills load when a task triggers them. The README has a diagnosing skill for sessions that burn more tokens than you expect.

• claude-mem. Search works in layers: a compact index first, at about 50 to 100 tokens per result, then full details only for the results you pick, at about 500 to 1,000 each. The README claims about 10 times fewer tokens from filtering first. That figure is the author's claim.

• ECC. Skills load on demand and rules are always loaded, so the README says to install rules selectively. Injected instincts are capped at 6 by default, with a minimum confidence of 0.7.

• Second Brain. Rules and facts load first and the rest on demand. The records stay small because each holds one kind of thing and gets reviewed.

Which one fits which problem

1. The AI plans without pushback. gstack's roles are built for that. Start there.
2. The AI skips steps or builds before it plans. Superpowers makes the steps a habit.
3. The AI forgets what happened last week. claude-mem replays history automatically.
4. You want portable memory files across tools. ECC's vault is plain Markdown.
5. The AI is confident about a fact that stopped being true. A dated record makes each fact's age visible. The other setups catch stale entries through manual review or pruning.

You can run more than one. A skill pack for how to work and a Second Brain for what is true is a combination I would choose before any single one of these.

Setup and personalization

The same five, compared on how much work it is to start and how much you can change.

Tool	Setup	Personalization
gstack	Clone the repo into ~/.claude/skills/gstack and run ./setup. It needs Bun. Team mode adds a command that commits the setup into the repo.	The commands are Markdown files and the README says to fork it and make it yours. Model choices per host are settings, and some hooks are opt-in.
Superpowers	One plugin command on Claude Code.	The README points to forking the repo for changes and gives one opt-out setting, for telemetry.
claude-mem	npx claude-mem install, a browser sign-in, and a local background service with its own database.	A settings file controls the AI model, worker port, data directory and what context is injected. A <private> tag keeps a passage out.
ECC	An npx command or the plugin marketplace, across several coding tools. The README warns against stacking install methods.	A /ecc:configure-ecc skill reconfigures it, and a setting caps how many instincts are injected. Memory has a project scope and a user scope.
Second Brain	Copy the plain Markdown files of the free Second Brain Starter. The assistant shows the setup plan before it writes anything. The initializer needs Node.js 22 or newer.	Everything it loads is a Markdown file you open and edit. The rules file decides the route, and you add the facts and decisions yourself.

The free Second Brain Starter is plain Markdown. Open it in Claude Code or Codex and type Set this up for me.

This one came from Code Meet AI, the newsletter where I write up the setups I actually run on my own projects.