Claude Code Manager

Context-aware router for managing Claude Code configuration - skills, slash commands, and subagents.

What This Skill Does

• Routes to appropriate builder based on user intent
• Provides guidance on Claude Code extensibility
• Shows available templates and examples
• Helps choose between skills, commands, and agents
• Maintains minimal token overhead (~300 tokens)

When to Use

1. User wants to create/improve a skill
2. User needs a custom slash command
3. User wants to configure a subagent
4. User asks "how do I extend Claude Code?"
5. User mentions "skill builder", "slash command", or "subagent"
6. User has repetitive prompts to automate

Configuration Categories

The Claude Code configuration system has 3 categories:

Category 1: Skills

Purpose: Build reusable AI capabilities Builder: skill-builder When: Create new AI functionality, improve discovery, fix activation Output: SKILL.md with YAML frontmatter, examples, reference � See: categories/1-skills/README.md

Category 2: Slash Commands

Purpose: Create prompt shortcuts Builder: command-builder When: Automate repetitive prompts, create team workflows Output: Slash command file in .claude/commands/ � See: categories/2-commands/README.md

Category 3: Subagents

Purpose: Configure specialized AI assistants Builder: agent-builder When: Need isolated context, specialized expertise, task delegation Output: Subagent config in .claude/agents/ � See: categories/3-agents/README.md

Decision Tree

What do you need?

Need AI to understand new capability automatically?
 � Category 1: Skills (skill-builder)
   Examples: "Create spec generator", "Build code analyzer"

Need shortcut for repetitive prompt?
 � Category 2: Slash Commands (command-builder)
   Examples: "/commit", "/review-pr", "/deploy"

Need dedicated AI assistant for specialized task?
 � Category 3: Subagents (agent-builder)
   Examples: Code reviewer, debugger, test runner

Quick Reference

Skills - AI capabilities that trigger automatically

• Discovered via description matching
• Progressive disclosure (3 levels)
• Can use tools (Read, Write, Bash, etc.)
• Example: spec:generate, spec:plan

Slash Commands - Prompt shortcuts

• Invoked explicitly with /command
• Support parameters: /deploy {env}
• Can include bash commands and file refs
• Example: /commit, /review-pr

Subagents - Specialized AI assistants

• Isolated context window
• Custom system prompts
• Configurable tool access
• Example: code-reviewer, debugger

Navigation Resources

For category overviews:

• Category 1 (Skills): See categories/1-skills/README.md
• Category 2 (Commands): See categories/2-commands/README.md
• Category 3 (Agents): See categories/3-agents/README.md

For builder details:

• skill-builder: See categories/1-skills/skill-builder/guide.md
• command-builder: See categories/2-commands/command-builder/guide.md
• agent-builder: See categories/3-agents/agent-builder/guide.md

For examples and templates:

• Skill templates: See templates/skills/
• Command templates: See templates/commands/
• Agent templates: See templates/agents/

Execution Flow

Step 1: Detect Intent

Analyze user request:

Keywords: "skill", "command", "agent", "subagent", "slash"
Context: What is user trying to accomplish?

Step 2: Route to Category

Based on intent:

• Skills � Load categories/1-skills/README.md
• Commands � Load categories/2-commands/README.md
• Agents � Load categories/3-agents/README.md
• Unclear � Show decision tree

Step 3: Provide Guidance

Show:

• Category overview
• Available builder
• Templates and examples
• Next steps

Step 4: Progressive Disclosure

If user needs more detail:

• Builder guide � Load [category]/[builder]/guide.md (~1,500 tokens)
• Examples � Load [category]/[builder]/examples.md (~3,000 tokens)
• Reference � Load [category]/[builder]/reference.md (~2,000 tokens)
• Templates � Load specific template file

Common Patterns

Creating a Skill:

1. Read categories/1-skills/README.md
2. Load skill-builder/guide.md
3. Review examples if needed
4. Generate SKILL.md with frontmatter
5. Create examples.md and reference.md
6. Validate and test

Creating a Slash Command:

1. Read categories/2-commands/README.md
2. Load command-builder/guide.md
3. Review command templates
4. Generate command markdown file
5. Test with /command-name

Creating a Subagent:

1. Read categories/3-agents/README.md
2. Load agent-builder/guide.md
3. Review agent templates
4. Generate agent config with frontmatter
5. Test delegation

Agent Coordination Strategies

When building workflows that require multiple agents to collaborate, consider these proven coordination patterns:

When to Use Multi-Agent Coordination

Use agent coordination when:

• Task requires multiple specialized perspectives
• Subtasks can be parallelized for speed
• Complex decomposition needs supervision
• Tasks have dependencies but some parallelism possible
• Need collaborative decision-making
• Event-driven automation required

Coordination Patterns

1. Sequential Pattern

Use when: Tasks must happen in strict order, each depends on previous output

Implementation:

// Example: Document processing pipeline
Task 1: Extract data → Output: structured JSON
Task 2: Analyze JSON → Output: insights report
Task 3: Summarize report → Output: executive summary

Config: Set agents.coordination.default_pattern: "sequential" in .claude/.spec-config.yml

Best for: Linear workflows, data transformation pipelines, stage-gated processes

---

2. Parallel Pattern

Use when: Tasks are completely independent, need maximum speed

Implementation:

// Example: Multi-language code review
Task A: Review Python files (independent)
Task B: Review TypeScript files (independent)
Task C: Review Go files (independent)

Execute all concurrently → Aggregate results

Config:

agents:
  coordination:
    parallel:
      max_concurrent_agents: 5
      collect_strategy: "all"  # all | first | any | majority

Best for: Batch processing, multi-language analysis, independent validations

---

3. Hierarchical Pattern

Use when: Task needs decomposition, supervision, quality review

Implementation:

// Example: Feature implementation with supervision
Supervisor (Sonnet model):
  - Decomposes task into subtasks
  - Delegates to worker agents (Haiku model)
  - Reviews each worker's output
  - Synthesizes final result

Workers: Execute subtasks independently

Config:

agents:
  coordination:
    hierarchical:
      supervisor_model: "sonnet"  # Intelligent coordinator
      worker_model: "haiku"       # Fast execution
      supervisor_reviews_work: true

Best for: Complex features, large tasks requiring decomposition, quality-critical work

---

4. DAG (Dependency Graph) Pattern

Use when: Mix of dependencies and parallelism, need optimal execution order

Implementation:

// Example: Build pipeline
Task A (no deps) ──┐
Task B (no deps) ──┼──→ Task D (depends on A,B)
Task C (no deps) ──┘            │
                                └──→ Task F (depends on D,E)
Task E (depends on C) ──────────────┘

Stage 1: A, B, C run in parallel
Stage 2: D, E run after dependencies met
Stage 3: F runs after D and E complete

Config:

agents:
  coordination:
    dag:
      auto_detect_dependencies: true
      critical_path_first: true
      parallel_non_dependent: true

Best for: CI/CD pipelines, build systems, task graphs with mixed dependencies

---

5. Group Chat Pattern

Use when: Need collaborative discussion, multiple perspectives, consensus

Implementation:

// Example: Architecture decision
Chat Manager: Facilitates discussion
Agent A: Scalability Expert
Agent B: Operations Expert
Agent C: Developer Experience Expert
Agent D: Cost Analyst

Rounds:
1. Each agent contributes perspective
2. Manager selects next speaker
3. Agents react to each other's input
4. Manager synthesizes consensus

Config:

agents:
  coordination:
    group_chat:
      max_agents: 4
      max_rounds: 10
      speaker_selection: "auto"  # auto | round_robin | manual

Best for: Architecture decisions, complex problem-solving, design reviews

---

6. Event-Driven Pattern

Use when: Tasks triggered by events, reactive automation

Implementation:

// Example: CI/CD automation
Event: git.commit → Linter Agent
Event: git.pull_request → Test Agent
Event: git.merge.main → Deploy Agent

Each agent subscribes to relevant events
Event bus dispatches to subscribers
Agents process events independently

Config:

agents:
  coordination:
    event_driven:
      event_bus: "memory"
      retry_on_failure: true
      dead_letter_queue: true

Best for: CI/CD pipelines, monitoring systems, reactive workflows

---

Pattern Selection Guide

Task Characteristic	Recommended Pattern
Strict sequential order	Sequential
No dependencies, need speed	Parallel
Needs supervision/review	Hierarchical
Some deps, some parallelism	DAG
Need collaboration	Group Chat
Event-triggered	Event-Driven

Integration with Spec Workflow

To use agent coordination in your Spec workflow:

1. Configure in .claude/.spec-config.yml:

   agents:
     coordination:
       default_pattern: "hierarchical"  # Your preferred pattern
       # Enable/configure each pattern as needed
   

2. Invoke agent-coordination skill:

   • User mentions "coordinate agents", "multi-agent", or "parallel execution"
   • Skill automatically loads configuration
   • Analyzes task and recommends optimal pattern
   • Executes coordination with progress tracking

3. Use in workflow phases:

   • Initialize: Parallel tool detection (linters, formatters, type checkers)
   • Define: Sequential spec generation → clarification → validation
   • Design: Hierarchical decomposition of technical planning
   • Build: DAG-based task execution with dependency tracking
   • Track: Parallel metrics collection

Examples

Example 1: Hierarchical coordination for feature implementation

# In build phase, supervisor decomposes feature into subtasks
# Workers execute subtasks in parallel where possible
# Supervisor reviews all work before completion

Example 2: DAG coordination for build pipeline

# Detects dependencies: lint/typecheck must pass before build
# Build must complete before tests
# Tests must pass before deploy
# Executes independent tasks (lint + typecheck) in parallel

Example 3: Group chat for architecture decision

# Multiple expert agents discuss microservices vs monolith
# Each contributes domain expertise
# Manager synthesizes consensus

Related Skills

• agent-coordination: Full multi-agent orchestration implementation
• workflow: Main Spec workflow (uses coordination internally)
• spec-implementer: Parallel task execution agent
• spec-researcher: Research-backed decisions agent
• spec-analyzer: Deep consistency validation agent

Best Practices

1. Start simple: Use Sequential for first implementation, optimize later
2. Profile first: Measure task duration before adding parallelism overhead
3. Configure thoughtfully: More agents != faster (coordination overhead exists)
4. Monitor metrics: Track parallelism factor, speedup, efficiency
5. Handle failures: Configure retries, timeouts, dead-letter queues

Performance Expectations

• Sequential: Baseline (no coordination overhead)
• Parallel: 2-4x speedup with 5 agents (typical)
• Hierarchical: 1.5-3x speedup (supervision overhead)
• DAG: 2-5x speedup (depends on dependency structure)
• Group Chat: Slower but higher decision quality
• Event-Driven: Variable (depends on event frequency)

---

For complete agent coordination documentation, see .claude/skills/agent-coordination/SKILL.md

Error Handling

Unclear intent:

• Show decision tree
• Ask clarifying questions
• Provide examples of each type

Multiple needs:

• List all applicable categories
• Explain differences
• Let user choose

Need all three:

• Create skills first (foundation)
• Then commands (shortcuts)
• Then agents (specialized tasks)

Output Format

Category Overview:

=� Category: [Skills|Commands|Agents]

Purpose: [What it does]
Builder: [Builder name]
When: [Use cases]
Output: [What gets created]

Available templates: [Count] templates
Need detail? Load [category]/README.md

Builder Guidance:

=' Builder: [name]

Process:
1. [Step 1]
2. [Step 2]
...

Templates available:
- [template-1.md]
- [template-2.md]

Examples: See [builder]/examples.md
Reference: See [builder]/reference.md

Token Efficiency

This router: ~300 tokens (lightweight, always loaded) Category READMEs: ~600 tokens each (loaded on demand) Builder guides: ~1,500 tokens each (loaded when needed) Examples: ~3,000 tokens (loaded only if stuck) Reference: ~2,000 tokens (loaded for deep dive)

Smart loading:

• Default: Show category overview
• User confirms: Load builder guide
• User needs patterns: Load examples
• User needs specs: Load reference

Related Resources

For developers: See individual builder guides For templates: See templates/[category]/ For best practices: See builder reference docs

---

Token Budget: ~300 tokens Progressive Disclosure: Router � Category � Builder � Examples � Reference