My Claude Code Setup: 68 Commands, 15 Agents, 86 Skills

I've been building with Claude Code for a few months. What started as a fancy autocomplete turned into something closer to a 15-person engineering org running in my terminal.

The numbers: 68 slash commands, 15 specialized agents, 86 skills, 9 MCP connections, 3 auto-hooks. Here's how the layers stack and why the composition matters more than any individual piece.

agents are the core abstraction

One general-purpose LLM is fine for one-off tasks. But for sustained product development you need specialization. Each agent has a single job and persistent memory:

• planner decomposes features before any code gets written
• tdd-guide enforces red-green-refactor — it literally won't let me skip writing tests first
• code-reviewer runs two-stage reviews: spec compliance, then code quality
• security-reviewer catches secrets, missing auth, injection risks
• architect makes system design calls and remembers them across sessions

Four of these agents have memory: user — they accumulate project knowledge over time. My code-reviewer knows the codebase patterns from 50+ past reviews. It doesn't re-learn the architecture every morning.

the command system

Everything is a slash command. A typical day:

/product-resume         # load all context from last session
/plan                   # break feature into implementation steps
/tdd                    # write tests first, then implement
/code-review            # two-stage review (spec + quality)
/security-review        # vulnerability check
/ship                   # push, create PR, run CI
/land-and-deploy        # merge, deploy, canary verify
/handoff                # save context for tomorrow

Each command orchestrates multiple agents. /product-develop alone triggers planning, architecture review, TDD, code review, security scan, and E2E testing. One command, six agent passes, zero manual coordination.

9 services, one interface

The MCP layer connects Claude Code to everything: Asana for tasks, Notion for specs, Supabase for database ops, Vercel for deploys, Chrome for browser testing, Exa for web search. I describe what I want. The system figures out which services to call.

Auto-hooks run silently on every session — syncing work to Asana, saving decisions to Obsidian, maintaining a working plan file. I never think about project management. It happens.

the multiplier effect

The leverage isn't any single tool. It's the composition. Three things compound:

Parallel execution. Independent agents run simultaneously. Security analysis, performance review, and type checking happen at the same time, not sequentially.

Persistent memory. The system gets better at my codebase over time. Past reviews, architectural decisions, and lessons learned carry forward. Session 50 is dramatically more productive than session 1.

Autonomous loops. For well-defined tasks, I start an agent loop and walk away. It plans, implements, tests, reviews, and commits. I review the diff when it's done.

The result: I shipped AssessAI — 200+ source files, 630+ tests, 275 assessment questions — in weeks. One person. One terminal.

The bar for what one person can ship keeps rising.