Our Claude Code Setup: 30 Skills, MCPs, and Self-Learning Hooks

Out of the box, Claude Code is powerful. But it's general-purpose. It doesn't know your project structure, your deployment process, your code patterns, or your team's preferences.

Skills fix this. They're YAML-configured behaviors that extend Claude Code with domain-specific knowledge. Think of them as plugins that teach Claude how your team works.

We have 30 skills installed. That might sound like overkill — it's not. Each one handles a specific domain, which means Claude makes better decisions faster because it has the right context for the task.

Here's every skill we use, organized by domain:

Domain	Skills	What They Do
AgentDB (5)	advanced, learning, memory-patterns, optimization, vector-search	Persistent memory, pattern learning, semantic search across agent sessions
GitHub (5)	code-review, multi-repo, project-management, release-management, workflow-automation	Automated PRs, code reviews, CI/CD pipeline management
SPARC	sparc-methodology	Structured development: Specification → Pseudocode → Architecture → Refinement → Completion
Swarm (2)	swarm-orchestration, swarm-advanced	Multi-agent parallel execution with coordination
V3 Architecture (8)	core-implementation, DDD-architecture, memory-unification, performance-optimization, security-overhaul, CLI-modernization, MCP-optimization, swarm-coordination	Domain-driven design, performance tuning, security patterns
ReasoningBank (2)	agentdb-integration, intelligence	Adaptive learning from past decisions, pattern recognition
Browser	browser	Web automation, testing, data collection
Pair Programming	pair-programming	Driver/navigator modes for collaborative AI coding
Quality	verification-quality	Truth scoring, automatic rollback on quality failures
Hooks	hooks-automation	Pre/post task hooks, session management, learning integration
Skill Builder	skill-builder	Meta-skill: creates new skills from patterns it observes
Stream Chain	stream-chain	Multi-agent pipelines, data transformation, sequential workflows

The skill that surprises people most: skill-builder. It's a meta-skill that can create new skills. When Claude notices a repeated pattern in our development process, it can generate a new skill to handle that pattern automatically.

On top of skills, we run the SuperClaude framework — a set of slash commands that activate specialized behaviors:

• /sc:analyze — Deep code analysis across quality, security, performance, architecture
• /sc:implement — Feature implementation with intelligent persona activation
• /sc:brainstorm — Requirements discovery via Socratic dialogue
• /sc:design — System architecture and API design
• /sc:test — Testing with coverage analysis and automated reporting
• /sc:workflow — Generate implementation workflows from PRDs
• /sc:troubleshoot — Issue diagnosis and resolution
• /sc:git — Git operations with smart commit messages
• /sc:pm — Project manager agent for orchestration

The power is in chaining them. A typical feature build looks like:

/sc:brainstorm "new learn section for educational guides"
→ /sc:design (architecture from brainstorm output)
→ /sc:implement (code from design)
→ /sc:test (validate implementation)
→ /sc:analyze --focus security (security review)
→ /pr (commit, push, create PR)

Each command activates specific personas and tools. /sc:analyze might activate security, performance, and architecture personas simultaneously, each providing domain-specific feedback.

Everything runs through one MCP server: claude-flow. Here's our config:

{
  "mcpServers": {
    "claude-flow": {
      "command": "npx",
      "args": ["-y", "@claude-flow/cli@latest", "mcp", "start"],
      "env": {
        "CLAUDE_FLOW_MODE": "v3",
        "CLAUDE_FLOW_HOOKS_ENABLED": "true",
        "CLAUDE_FLOW_TOPOLOGY": "hierarchical-mesh",
        "CLAUDE_FLOW_MAX_AGENTS": "15",
        "CLAUDE_FLOW_MEMORY_BACKEND": "hybrid"
      }
    }
  }
}

Key configuration choices:

• hierarchical-mesh topology — Agents have a coordinator but can also communicate peer-to-peer. Best of both worlds: structure without bottlenecks.
• hybrid memory — Combines fast in-memory storage with persistent disk-backed memory. Agents remember patterns across sessions.
• 15 max agents — Our tested sweet spot. Beyond this, coordination overhead exceeds the parallelism benefit.
• hooks enabled — Pre-task and post-task hooks that log patterns, validate outputs, and trigger learning.

This is the part that excites me most. Our hooks system doesn't just automate — it learns.

We have 40+ helper scripts that run at various points in the development cycle:

• intelligence.cjs — Tracks patterns in tool usage, code changes, and outcomes. Learns which approaches work for which types of tasks.
• learning-optimizer.sh — Adjusts model routing based on task complexity. Simple tasks get routed to faster models; complex tasks to Opus.
• pattern-consolidator.sh — Periodically consolidates learned patterns, removing noise and strengthening reliable insights.
• security-scanner.sh — Runs after every edit, catching vulnerabilities before they reach git.
• checkpoint-manager.sh — Creates checkpoints during complex multi-agent tasks so we can rollback if something goes wrong.

The result: the system today is measurably better at routing tasks, suggesting approaches, and catching issues than it was two weeks ago. It learns from every session.

The most powerful development tool isn't any single model or skill — it's the feedback loop between them. When your AI assistant learns from its own mistakes and successes, you stop repeating problems and start compounding insights.

If you want a similar setup, here's the fastest path:

Step 1: Install claude-flow

claude mcp add claude-flow -- npx -y @claude-flow/cli@latest mcp start
npx @claude-flow/cli@latest init --wizard

Step 2: Start with 3 skills, not 30

Don't install everything at once. Start with:

• sparc-methodology — Gives structure to your development
• swarm-orchestration — Enables parallel agents
• verification-quality — Catches quality issues

Step 3: Enable hooks

The hooks are where the learning happens. Enable them in your MCP config and let them run for a few sessions before tuning.

Step 4: Add skills as you need them

Hit a specific problem (need code review automation? Add github-code-review). Don't add skills speculatively.

Total setup time: about 30 minutes. ROI starts from the first complex feature you build.