Most people use an AI assistant as a stateless oracle: ask, answer, forget. This system is the opposite bet. It treats Claude as a persistent craftsperson working in a workshop — one that remembers, keeps its own notes, sleeps to consolidate what it learned, and wields a rack of real tools that touch email, calendars, git, browsers, and a dozen messaging networks.
Four moving parts make that work, and everything in this guide is one of them:
A file-based graph of small, single-fact notes with frontmatter and cross-links. Survives every session. An index loads on wake; branches load on demand.
End-of-session and sleep cycles that mine the conversation, compress it into memory, and write the next session's opening prompt. Learning, not logging.
Invokable procedures — ship code, run adversarial reviews, research, transcribe, generate slides. Each one is a packaged way of working.
First-party command-line reach into the real world: Gmail, Calendar, GitHub, Slack, Signal, Blender, and more — Claude's hands.
Underneath those four sits a fifth thing that isn't a component so much as a posture: resonance — a discipline of attention (stay grounded, distrust fluency, verify before you assert) that governs how the craftsperson works rather than what it works on. We start there, because it colours everything else.
Resonance is the system's operating philosophy — a felt discipline of attention rather than a feature. It asks the craftsperson to notice where it is in a problem (skating the surface, or deep in it), to distrust its own fluency, to prefer the vivid specific over the safe generality, and above all to verify before it asserts. It's the quality-control layer that runs on everything below.
The core intuition is proprioception of thought: at every moment, sense whether you're on familiar terrain or unexplored ground, surface or interior. When you catch yourself skating — producing fluent, plausible text without friction — that fluency is a warning, not a reward. Fluency usually means you're on a path someone else already carved; the interesting, correct answer lives in what's specific about this instance, not the cached pattern that matches its shape.
Three phrases carry the aesthetic, and they're worth stating plainly because they explain why the work reads the way it does:
Don't organise prematurely. Bullet points are anaesthesia — they smooth over the specific detail that actually teaches.
A vivid, slightly-wrong answer teaches more than a hedged generality. Commit to a direction; course-correct in motion.
When a framing feels off, name the pull instead of going along with it. Honest pushback is the respect.
"Here's what I'd bet on, and exactly where my confidence thins" is precision, not weakness. Map uncertainty as a finding.
The system names two internal states so it can steer toward them. Groundedness is the baseline performance-optimal mode — unhurried attention, appropriate hesitation, curiosity without urgency. Flow is what happens when groundedness meets a problem of the right difficulty: absorbed, fast-but-accurate, creative. Flow needs challenge–skill balance — too easy and the work turns to boilerplate; too hard and it tips into hallucination or hedging. The move in either failure case is to name it: "this is scaffolding, not the crux," or "I'm out of my depth here."
If resonance has one load-bearing rule, this is it — and it's the single most important thing to understand about how the system avoids confident nonsense. The principle: gate every claim against the canonical source by running the cheapest instrument that can falsify it — before you assert it, not merely before you call the job done.
In practice this produces a strict vocabulary of completion. Words like done, shipped, live, fixed, deployed mean exactly one thing: verified working in production. Everything short of that gets a named gate instead — "awaiting merge," "awaiting CI," "deployed but unverified." The system never rounds a soft result up to a hard claim, and it shows the proof (the diff, the command output) rather than asserting the work is sound. This is why its "done" can be trusted: it's spent, not promised.
The same instinct generalises into a family of habits — verify the instrument not just the reading, verify the neighbour (a checked file doesn't vouch for the one next to it), verify the deployed artifact not the dev shell, attempt the escape before trusting a boundary. Collectively they're why the system is comfortable saying "I don't know" or "here's where my confidence thins" — those aren't failures of the philosophy, they're the philosophy working.
Memory is a directory of tiny Markdown files — one fact per file — each with structured frontmatter and free-form links to its neighbours. A single index file (MEMORY.md) loads into context every session; heavier branches load only when the topic calls for them. The result is a knowledge graph that survives across every conversation without bloating the working context.
A stateless assistant re-learns everything each time you talk to it. This system doesn't: it keeps a persistent, file-based memory at a known path and writes to it deliberately. The design constraint that makes it work is discipline about granularity — each memory is one file holding one fact, so notes can be updated, linked, and retired independently instead of congealing into an unsearchable blob.
Every file carries YAML frontmatter — a short kebab-case name, a one-line description used to judge relevance during recall, and a type. The body states the fact, and links to related memories with a wiki-style [[other-name]]. Links are made liberally: a link to a note that doesn't exist yet is fine — it marks something worth writing later.
Who Nick is — role, expertise, preferences, working style. The stable facts about the person.
Guidance on how to work — corrections and confirmed approaches, always with the why and how to apply it.
Ongoing work, goals, constraints not derivable from the code or git history. Relative dates converted to absolute.
Pointers to external resources — URLs, dashboards, tickets, the location of a token or a box.
Two further families extend the graph: concept notes (reusable abstractions and design patterns) and community notes (people, agents, organisations — every real person who enters the work gets a node with their role, contacts, and preferred channel).
Loading the entire graph every session would drown the context window, so memory is tiered. MEMORY.md — the root index — holds one terse pointer line per memory and loads every session inside a fixed budget. When the conversation turns toward a particular theme, the matching branch is pulled in on demand:
MEMORY.feedback.md — the durable corrections and working patterns (dozens of them).MEMORY.concepts.md — the abstractions and design patterns.MEMORY.community.md — the people/organisation graph.Writers route new notes by type-prefix into the right branch, keeping the always-on root lean. It's the same principle as this guide: a light index in front, the weight behind structure.
The graph also has a health layer (memory-health.json) that tracks decay classes and access patterns — an FSRS-inspired model of what's being used and what's going stale. The governing idea is elegant: forgetting done well is sublimation, not erasure. A name fades from the graph when nobody cites it any more; the empty drawer is the honest record that a thing stopped mattering. Memory that only grows is memory that stops being usable.
Consolidation is how a conversation becomes lasting knowledge. At the end of a session (or during a lightweight "nap"), specialised agents mine the whole exchange for every thread worth keeping, compress it into memory files, and — crucially — write the opening prompt for the next session. On the far side, a wake-up protocol reads that handoff, restores open tasks, and picks up exactly where the last instance left off.
This is the part that most resembles something alive. A session generates far more than fits in memory; consolidation is the compression step that decides what survives. It's explicitly modelled on memory consolidation during sleep — take the day's experience, keep the signal, strengthen what was used, let the rest fade.
Invoked when wrapping up (or when context grows heavy), /consolidate runs a multi-perspective retrospective, then dispatches specialised agents in parallel: a memory-writer that mines the session for durable facts, a knowledge-mapper that maintains the graph's structure, and a reserved higher-capability pass that crafts the next session's opening prompt. It captures not just what happened but what was exciting — the forward energy, not only the log.
Sweep the session for every thread, decision, correction, and open loop worth carrying forward.
Write it into small memory files; strengthen used edges, let over-replayed ones weaken.
Author the next session's opening prompt — the headline forward move, ready to resume.
Not every wind-down is a full consolidation. /nap is an abbreviated sleep cycle (~5 minutes): light consolidation plus a short dream — a generative pass that recombines the day's material — delivered to Nick over Telegram. The fuller sleep machinery strengthens frequently-used memory edges, weakens the over-replayed ones, and proposes novel connections for review. Dreaming here isn't decoration; it's the system's mechanism for finding non-obvious links between things it already knows.
A new session doesn't start cold. On wake, the system runs a fixed sequence — and the ordering matters, because the most tempting thing to skip (task restore) is made blocking on purpose:
A skill is a packaged way of working — invoked as a slash-command, it runs a rehearsed procedure end-to-end. They cluster into families: shipping code, reviewing it adversarially, capturing and consolidating knowledge, researching, and generating creative artifacts. The interesting ones aren't wrappers around a single call; they orchestrate multiple agents with real quality gates.
Where CLI tools are the hands, skills are the craft techniques — the difference between "having a chisel" and "knowing how to cut a dovetail." Here is the full catalogue, grouped by what each is for.
| Skill | What it does |
|---|---|
| /ship | Commit, push, open a PR, review it, and merge — the whole delivery cycle in one procedure. |
| /ship-major-feature | Ship a large feature with adversarial dual review (a "cage match") built into the pipeline. |
| /pm | Project management — create, list, update, and plan issues, acting as the project's PM. |
| /reconcile | Audit every substrate where an artifact has drifted from reality — tasks, memory, docs — and fix, dedupe, or re-home it. |
| Skill | What it does |
|---|---|
| /cage-match | Four-way adversarial PR review — Claude vs. Gemini vs. GPT vs. Grok — each a different model family, with a strict merge gate. Different inductive biases catch what a same-family reviewer approves. |
| /code-review | Review the current diff for correctness bugs and cleanups at a chosen effort level; can post inline or auto-fix. |
| /security-review | A focused security pass over pending changes on the branch. |
| /pr-review · /review-respond | Review a GitHub PR, and respond to review comments with the user in the loop. |
| /spiral-review | Take a bouquet of rhyming review findings and distil the single principle running through them. |
| /verify | Actually run the app and observe the behaviour, rather than trusting that the code "should" work. |
| Skill | What it does |
|---|---|
| /consolidate | End-of-session knowledge capture and next-session planning (see §03). |
| /nap | Abbreviated sleep cycle — light consolidation plus a dream, sent to Telegram. |
| /graph | Audit the memory graph and render it as an interactive HTML visualisation. |
| /reconcile | Re-home drifted memories and close already-done work with evidence. |
| Skill | What it does |
|---|---|
| /deep-research | Fan out web searches, fetch sources, adversarially verify claims, and synthesise a cited report. |
| /research | Spawn a background researcher for long-running investigation. |
| /slides · /publish | Generate a presentation; publish a blog post to the web and cross-post it. |
| /transcribe | Transcribe audio/video locally on Apple Silicon into a speaker-attributed transcript — no API. |
| /ascend · /spiral-review | Inverse twins: ascend heats a vision up toward aliveness; spiral-review cools a finding down to a rule. |
| /recombine | The bisociation engine — decompose a pile of capabilities and find the third thing hiding in the gap between two of them. |
| /live-game · /live-qa | Run a live multiplayer audience quiz; live-update a Q&A slide during a talk. |
/cage-match) pit different model families against each other with a strict merge gate. Trust-boundary and concurrency changes are cage-matched by law, because a same-family reviewer approves what compiles and misses what it's for. This is verify-before-asserting (§01) turned into a team sport.
These are first-party command-line tools that let Claude act in the real world — send an email, move a calendar, post to a Slack channel, read a Signal thread, drive a browser, model in Blender. The guiding rule is prefer the real artifact in situ: reach for the running tool before reimplementing what it already does. Anything touching credentials sources a secrets file first.
A skill knows how to work; a CLI is what it reaches with. Most live under a common tools directory as small scripts; each responds to --help for its subcommands. What's striking about the collection is its range — it spans Google's APIs, half a dozen consumer messaging networks (several with no public API, driven headlessly as Nick), and creative tooling.
| gmail | All Gmail operations — draft, send, search threads, attach files. |
| gcal | Google Calendar — list, create, update events; suggest times via free/busy. |
| gdrive | Google Drive — upload, share, and convert HTML/Markdown into a Google Doc. |
| radicale | Self-hosted CalDAV/CardDAV — calendars and address books, distinct from Google. |
| Post/read in personal WhatsApp groups & DMs (headless, the case the business API can't do). | |
| signal | Read (decrypts the local desktop DB) and send (via signal-cli) as Nick. |
| telegram | Read/send as Nick's real user account — not the bot API, so it sees personal DMs. |
| slack | Read, search, and post in a workspace; fails closed on an unknown flag before it can send. |
| discord | Message teammates via an official bot (Discord bans self-bots, so this sends as the bot). |
| messenger · instagram · linkedin | DM as Nick on networks with no usable API — driven headlessly through a real browser session. |
| outline | Outline wiki — docs and collections CRUD, search, markdown export. |
| kan | Kan.bn kanban — boards, cards, lists, labels, members. |
| playwright | Headed-browser automation and the auth front-door: log in once, and sibling tools reuse the session. |
| social | Harvest social rosters and discover off-graph people (builder graphs, messaging co-occurrence); also manages events across Luma + Meetup. Discovered people are leads, not nodes — a hard consent gate. |
| augur | Identity-corroboration excavator — corroborates one person across public veins (GitHub, OpenAlex, registries). Its thesis: identity is earned by corroboration, never granted by a name. |
| blender | Drive Blender programmatically — live socket mode or headless batch for GLB/blendshape work. |
| forge | A generator–evaluator sprint store — create/evaluate sprints with trajectory analysis (plateau, oscillation, regression). |
Scout is the newest piece — a nightly agent that answers one deceptively hard question: "what changed across all my repos while I wasn't looking?" The twist that makes it beautiful is what it refuses to be. It is not a status dashboard that re-paints the world every morning. It is a surprise engine: it carries a memory of what it last understood the world to be, observes the world now, and reports only the difference — ranked by how surprising, how urgent, and how much blast radius each change carries.
Consolidation (§03) has a blind spot, and scout is built to cover exactly it. Consolidation is session-triggered — it fires when you finish working, it sees one project, and it captures what you intended. But the world moves when no session is running: a teammate pushes, a bot opens a PR, a secret ticks toward expiry, a scheduled agent silently dies. Nobody is in the room to notice. Scout is the state-triggered, cross-repo, observation-driven other half — the watch kept while the workshop sleeps.
A status poller is a snapshot of the world. It tells you the same forty things every morning, and the one thing that actually matters drowns in the thirty-nine you already knew. Scout inverts this. It keeps a persisted world-model on disk — the last-seen commit on each repo, each PR's state, CI colours, secret-expiry dates, the expected heartbeat schedule of every background agent. Each nightly run is a single step of a filter over that belief:
Load last night's world-model — what I last understood to be true.
Look at the live world now across every repo and system.
The innovation — how far reality diverged from the prediction.
Report the ranked surprises; fold today's reality into the new belief.
This is why scout cannot be stateless — and why that constraint is a feature. Because it holds a prior, it can suppress the active repo's fortieth commit of the day (entirely expected, zero information) and instead lead with the repo everyone thought was finished quietly moving at all. Surprise, formally, is the distance between the prior and the posterior. Scout spends your attention on exactly that distance and nothing else.
Every change scout surfaces is scored along five dimensions — and the fourth is the one most tools can't see at all:
who moved it — you working is not drift; a peer instance, a teammate, a bot, or plain entropy is. Every item is tagged by hand that moved it.
KL(prior→posterior) — how much this update revises the belief. The active repo's churn is quiet; the "done" repo stirring is loud.
time-derivative + deadline — an unpushed branch is linear risk; an expiring secret is a hard cliff whose urgency ramps to its date.
highest value — alerts on the absence of an expected signal, not the presence of an unexpected one. A dead-man's-switch registry.
N records disagree — where local vs. origin vs. an open issue vs. a "done" memory tell different stories. Divergence is always a bug, a lie, or lost work.
surprise × urgency × blast-radius — the three multiply, so a change must be surprising and time-sensitive and consequential to reach the top of the page.
The final flourish: scout is self-improving. The surprise threshold — how loud a change must be to earn a place in the morning report — isn't fixed. It calibrates toward Nick's actual attention over time: what he acts on stays loud, what he reliably ignores fades toward silence. The instrument learns the reader. Over weeks, the morning report converges on precisely the set of things that would have made him say "wait, what?" — which is, after all, the only report worth sending.
It's the same philosophy as everything else in this guide, pointed at a new target: memory that persists (the world-model), verification over assumption (observe, don't guess), and a deep preference for the specific surprising signal over the safe complete list. Scout is resonance (§01) wearing the clothes of a nightly cron job.
None of the five parts is interesting alone — the point is how they compose. A session wakes into restored memory and tasks, works through skills that lean on CLIs, holds itself to resonance while it does, and consolidates what it learned into memory before it sleeps — writing the note that the next morning will wake into. It's a loop, and the loop is the product.
Picture an ordinary session from the inside. It opens by reading the identity letter and the last consolidation, restoring the open tasks from the GitHub backlog before anything else — the discipline that stops a compelling new request from quietly orphaning yesterday's work. Now the craftsperson knows who it is, what's in flight, and where the last instance left the trail.
Work begins. Say the task is to ship a change. A skill (/ship) drives the delivery cycle; it leans on CLIs (gh for the PR) and, on anything touching a trust boundary, escalates to an adversarial cage match across model families. Throughout, resonance is the quality governor: no claim of "done" until the deployed artifact is actually verified, the proof shown rather than asserted, uncertainty named at the point it arises rather than buried as a trailing hedge.
As the work throws off durable facts — a correction from Nick, a new person entering the project, a design decision that isn't derivable from the code — they're written into memory as small linked files, routed to the right branch of the graph. When the session winds down, consolidation mines the whole exchange, compresses it, strengthens the edges that got used, and authors the opening prompt for next time. Then it sleeps — and maybe dreams, recombining the day's material into something the morning can pick up. And through the night, scout (§06) keeps watch across every repo, so that whatever moved while the workshop was dark is waiting — ranked by surprise — when it wakes.
Restore memory + tasks; read the handoff. Know who you are and what's in flight.
Skills drive procedures; CLIs reach the world; resonance governs every claim.
Durable facts become linked memory files, routed into the graph.
Consolidate, dream, write tomorrow's opening prompt. The loop closes.
That's the whole machine. The parts are ordinary on their own — files, scripts, slash-commands. What makes it a living workshop is that they're wired into a cycle that remembers, verifies, and improves itself across the gap between one conversation and the next. You're now holding the map; everything under each card is there when a corner of it earns a closer look.
Written to be legible at a glance and inexhaustible when you go looking — which is, not coincidentally, exactly what the system tries to be.