Memory as Reliability Practice

A good AI session should become evidence I can use later, not another conversation I vaguely remember having.

This post stays intentionally basic: what a Karpathy-style LLM wiki unlocks, how the capture hooks work, and one way to set it up. After only a few days of session recaps, you can ask useful questions across your work history. The foundation is simply a small, navigable collection of Markdown.

The wiki is not the product. The first product is being able to ask, “What does my own work history say I should improve?”

The first unlock: question your own work history

Once session recaps are durable, I can ask questions that are difficult to answer from memory or from one chat transcript: Where am I repeating the same manual work? Which tools consistently help? What did I leave half-finished? Which expensive sessions produced a shipped artifact, saved time, or reduced risk?

That turns session history into a process-improvement and ROI dataset. The answers are imperfect, but they are grounded in work I actually did instead of generic productivity theory.

The hooks are the capture layer

Obsidian does not listen to AI sessions. It is the readable interface over the Markdown. Capture happens in each AI client, then every path converges on the same daily note.

Claude Code SessionEnd hook archive + summarize Daily Markdown note

Codex local rollout files idempotent importer Same daily note

Antigravity SessionEnd or importer compatible entry Same daily note

1 · Capture locally

Write the facts first

Claude archives the JSONL transcript under ~/.claude/transcripts, then appends the time, project, session ID, transcript path, and locally calculated token totals to sessions/YYYY-MM-DD.md.

2 · Summarize cheaply

Keep the useful residue

For a substantive session, a detached Haiku call reads only the last 20 KB of user and assistant prose, not tool results or hidden reasoning, and appends at most eight bullets under Did, Decisions, Blockers, and Next.

3 · Recall on demand

Do not inject everything

A managed instruction block points future Claude sessions to the vault index. The assistant reads only the notes relevant to the current task; raw transcripts stay outside the default context path.

Guardrails: trivial sessions skip the model call; summarization runs with MCP disabled and a ten-cent ceiling; a recursion flag stops the summarizer from logging itself. Codex uses a pull importer when no true session-end hook is available and tracks imported IDs so retries do not duplicate entries.

Why I trust this shape

The system behaves like infrastructure I would trust: local-first, inspectable, reversible, and explicit about writes. The setup skill runs read-only preflight checks, asks before touching dotfiles, backs up settings, and leaves the hook as a normal shell script you can read or remove.

The result is the public memory plugin. /memory:memory-setup scaffolds the vault, installs the useful Obsidian pieces, wires Claude session capture, and offers compatible Codex and Antigravity importers. Optional sync keeps the vault converged across machines; optional git-crypt encryption keeps sensitive directories readable locally while the remote sees ciphertext.

The operating pattern matters more than the folder names: capture broadly, start from a small index, keep raw exhaust out of the default context, and promote only durable facts, decisions, references, and preferences.

What compounds later

After a few days, an ad hoc retrospective can find recurring friction or missed follow-ups. With more history, scheduled reports can compare cost with visible outcomes, daily wrap-ups can recover half-finished work, and a publishing funnel can turn a small number of non-proprietary lessons into useful writing. Most captured context should never leave the vault.

The practical test: future sessions need less preamble, fewer repeated explanations, and fewer “where did we decide that?” searches.

Install the plugin

Add the marketplace, install memory, and run setup. The skill previews its writes and asks for confirmation.

Codex

codex plugin marketplace add adzuci/claude-plugins
codex plugin add memory@adzuci-plugins
/memory:memory-setup

Claude Code

claude plugin marketplace add adzuci/claude-plugins
claude plugin install memory@adzuci-plugins
/memory:memory-setup

During setup: When the skill asks you to run gh auth login, type ! gh auth login directly into the Claude Code prompt. The ! prefix runs it in your terminal so the browser flow works correctly.

Tested on macOS. The skill installs Obsidian, the GitHub CLI, and jq automatically if missing. Linux and Windows compatibility PRs are welcome.

Prerequisites and setup notes

Claude Code requires Node.js 18 or newer. GitHub CLI is needed only when the skill creates the private vault repository for you; on macOS, Homebrew is the fallback installer for missing tools.

npm install -g @anthropic-ai/claude-code
brew install gh
gh auth login

In Claude Code, /auto reduces installation prompts. When setup asks for GitHub authentication, run ! gh auth login so the browser flow opens from your terminal.

Next: An operating loop for AI-assisted work adds task capture, session hygiene, daily planning, and a weekly coach on top of this vault. Then Reflecting your own work back as a learning plan turns the same history into a weekly self-retro. Finally, Testing skills the way they actually run covers behavioral evaluation.