People keep asking what my "AI setup" actually looks like — which model, which tools, how the autonomy doesn't turn into chaos. So here's the whole thing, top to bottom: the models, the MCP servers, the agents, the memory layer, the skills, and the hooks that keep it honest.
The short version: Claude Code is the runtime, and everything else is plumbing I bolted on until the loop stopped fighting me. The interesting part isn't what I added — it's what I deleted.
The brains — which models actually run
Two Claude models do ~95% of the work, on purpose:
- Opus 4.8 (1M context) — the driver. Planning, multi-file edits, the hard reasoning, anything that touches architecture. The 1M window means I rarely have to babysit context on a big repo.
- Sonnet 4.6 — the reviewer. My pre-commit code-review hook runs on Sonnet, not Opus. It's fast, it's cheap, and for "did this diff just introduce a SQL injection" it's more than enough. No reason to burn Opus on a gate that fires on every commit.
On top of that I keep a model playground wired in through Qubu (more on that below), so I can fan a prompt across other models when I want a second opinion or need a non-Claude modality. But the daily loop is Opus-drives-Sonnet-reviews, and that split alone cut my cost without me noticing any quality drop.
The hands — MCP servers
MCP is where Claude stops being a chatbot and starts being able to do things. Ten servers run globally for me; the rest are per-project. The global set:
- qubu — my own AI platform. Models, datasets, notebooks, inference, a generation playground, even the forum/journal. This is also what I use to generate media.
- context7 — live, version-accurate library docs. Knowledge cutoffs lie about minor versions; this doesn't. I reach for it before trusting my own memory on any framework API.
- figma-desktop + figma-developer-mcp — design → code without the screenshot-and-guess dance. Real variables, real metadata, real layout.
- kie-ai — image/video generation when I need media inline.
- cloudflare-api — DNS, Workers, the whole CF surface across several accounts, from the terminal.
- mt-glitch-blog — yes, the server I'm publishing this post through. Create, update, upload covers — the blog is just another tool call.
- agent-browser + playwright — two browser drivers. Snapshot a page, click through a flow, scrape, or run a real E2E check.
- markdowner — turn any URL/document into clean Markdown so it's actually usable in context.
Per-project I layer in more: SSH MCPs into infra, Postgres/pgbouncer MCPs, Sentry, Vercel, a YouGile board MCP. The point isn't to have many — it's that each repo only sees the servers it needs.
The memory — claude-mem
Stock Claude Code forgets everything when the session ends. claude-mem fixes that. It captures observations as I work — decisions, discoveries, bugfixes — into a persistent, cross-session store, and surfaces the relevant ones at the start of the next session.
In practice it means I can open a cold session weeks later and ask "how did we solve the LSP setup last time?" and it actually knows. It also drives a timeline and a searchable memory I query with mem-search instead of re-deriving context I already paid for once. Combined with context-mode — which keeps raw tool output (logs, snapshots, big command dumps) out of the window and only feeds me the searchable summary — my context window stays clean even on long, messy debugging sessions.
The crew — agents
Not everything should run in the main loop. Agents are specialists I dispatch:
- code-reviewer (custom, Sonnet) — the one I lean on hardest. Runs on the branch diff, classifies findings as CRITICAL vs MINOR. Critical → it stops and pings my Telegram. Minor → it just fixes them in the working tree and tells me what it touched. It runs on
/review and automatically on every git commit via a hook.
- GSD agents — a pipeline of narrow roles:
gsd-roadmapper, gsd-ui-researcher, gsd-security-auditor, gsd-eval-planner, gsd-doc-verifier, and friends. Each one owns a single phase of a planned build and nothing else.
- The built-in fleet — dozens of specialist subagent types I fan out to for parallel work (exploration, research, structured reviews) when one context can't hold the whole job.
The muscle memory — skills (and why I deleted most of them)
Skills are reusable procedures Claude pulls in on demand — TDD discipline, debugging method, planning, frontend design, Vercel deploys, the whole superpowers and GSD families, Karpathy's skill set, my own.
Here's the thing nobody tells you: more skills is not better. Every installed skill's description sits in the trigger surface, and a bloated surface means the wrong skill fires, or three fire at once, or the model burns reasoning deciding between them. So I went through the full catalogue with a "would a staff engineer actually invoke this?" filter and cut the majority of them. Anything redundant, anything novelty, anything I hadn't triggered in real work — gone.
What survived is a tight set: brainstorming and planning, systematic debugging, TDD, code review, context-mode, claude-mem's search/plan/do trio, frontend-design, the Vercel family for deploys, and skill-creator for building new ones. Eight plugins enabled, not eighty. The loop got more reliable by having fewer options.
The reflexes — hooks
Hooks are what make the autonomy safe to leave running. Mine:
- Pre-commit code review — a
PreToolUse hook on git commit spins up the Sonnet reviewer. CRITICAL findings block the commit; minor ones get auto-fixed in the tree. I can't accidentally commit an injection.
- AI Diff Viewer —
Write/Edit fire my own VSCode extension so every AI edit lands as an inline, reviewable hunk instead of a silent file write.
- MCP runaway guard — a hook on every
mcp__* call that kills runaway tool loops before they cost me real money.
- Push notifications — when a long job finishes or needs input, it pings my phone. I don't sit and watch the terminal.
┌──────────────────────────┐
│ Opus 4.8 (1M) — driver │
└────────────┬─────────────┘
┌────────────────────────┼────────────────────────┐
▼ ▼ ▼
┌───────────┐ ┌──────────────┐ ┌─────────────┐
│ Skills │ │ MCP servers │ │ Agents │
│ (curated). │ │ qubu · cf · │ │ code-review │
│ tdd·debug. │ │ figma·browser. │ │ (Sonnet) │
│ ·plan │ │ ·blog·docs │ │ GSD·fleet │
└───────────┘ └──────────────┘ └─────────────┘
└────────────────────────┼────────────────────────┘
▼
┌──────────────────────────────────────────┐
│ claude-mem (memory) + context-mode (ctx) │
└──────────────────────────────────────────┘
▼
hooks: pre-commit review · ai-diff-viewer · runaway guard · push
The one principle
If there's a takeaway, it's this: an AI stack is a curation problem, not a collection problem. Every model, server, agent, and skill you add widens the surface the model has to reason over. The setups that actually feel like magic are the ones where someone was ruthless about what not to include.
Opus drives. Sonnet reviews. Ten MCP servers, not fifty. Eight plugins, not eighty. A memory layer so nothing's re-learned twice, and hooks so I can walk away. That's the whole thing.