Agent Selector Skill

Agent Selector Skill

Activation

Triggered after Phase 5 (Task Decomposition) completes:

[ACTIVATE:AGENT_SELECTOR_V1]

Purpose

Analyze PRD to determine optimal agent selection for the project.

Execution Flow

Step 1: Extract Tech Stack from PRD

Read PRD Section 8 (Technical Architecture) and identify:

languages:
  - primary: TypeScript
  - secondary: Python

frameworks:
  - frontend: Next.js, React
  - backend: FastAPI

databases:
  - primary: PostgreSQL
  - graph: Neo4j

infrastructure:
  - cloud: AWS
  - containers: Docker, Kubernetes
  - iac: Terraform

special_domains:
  - ml: false
  - blockchain: false
  - gaming: false
  - spatial: false

Step 2: Map to Agents

Use the agent mapping table:

Step 3: Determine Security Level

From PRD Section 11 (Security Requirements):

Step 4: Check Scale Requirements

From PRD Section 6 (Non-Functional Requirements):

Step 5: Generate agent-config.json

{
  "version": "1.0.0",
  "source": {
    "local": "agents/",
    "upstream_repo": "https://github.com/​turbobeest/​agents",
    "note": "Agents bundled locally"
  },
  "agents": {
    "core": {
      "include": [
        "orchestration-intelligence/​core-orchestration/​orchestrator",
        "orchestration-intelligence/​planning-assignment/​planning-agent",
        "orchestration-intelligence/​quality-control/​validation-depth-controller"
      ]
    },
    "auditors": {
      "include": [
        "infrastructure-security/​security-compliance/​security-auditor",
        "development-architecture/​system-architecture/​architect-reviewer"
      ]
    },
    "tech-stack": {
      "languages": ["typescript-pro", "python-pro"],
      "frameworks": ["nextjs-expert", "reactjs-expert"],
      "databases": ["sql-pro", "neo4j-expert"],
      "infrastructure": ["aws-expert", "docker-expert", "kubernetes-expert"]
    }
  },
  "phase-gates": {
    "4": ["security-auditor"],
    "8": ["architect-reviewer", "security-auditor"],
    "11": ["security-auditor"]
  }
}

Step 6: Present to User

╔═══════════════════════════════════════════════════════════════════════╗
║                         AGENT SELECTION                                ║
╠═══════════════════════════════════════════════════════════════════════╣
║                                                                        ║
║  Based on your PRD, I recommend the following agents:                 ║
║                                                                        ║
║  CORE (always included):                                              ║
║    • orchestrator         - Pipeline coordination                      ║
║    • planning-agent       - Task planning                              ║
║    • validation-controller - Quality gates                             ║
║                                                                        ║
║  LANGUAGES:                                                            ║
║    • typescript-pro       - TypeScript expertise                       ║
║    • python-pro           - Python/​FastAPI expertise                   ║
║                                                                        ║
║  FRAMEWORKS:                                                           ║
║    • nextjs-expert        - Next.js patterns                           ║
║    • reactjs-expert       - React best practices                       ║
║                                                                        ║
║  DATABASES:                                                            ║
║    • sql-pro              - PostgreSQL optimization                    ║
║    • neo4j-expert         - Graph database patterns                    ║
║                                                                        ║
║  INFRASTRUCTURE:                                                       ║
║    • aws-expert           - AWS services                               ║
║    • docker-expert        - Containerization                           ║
║    • kubernetes-expert    - K8s deployment                             ║
║                                                                        ║
║  AUDITORS (phase gates):                                               ║
║    • security-auditor     - Required: Phase 4, 8, 11                   ║
║    • architect-reviewer   - Required: Phase 8                          ║
║                                                                        ║
╠═══════════════════════════════════════════════════════════════════════╣
║  [A] Accept  [C] Customize  [S] Skip agents                           ║
╚═══════════════════════════════════════════════════════════════════════╝

Step 7: Sync Agents

On acceptance (agents are bundled locally in agents/):

./​scripts/​pull-agents.sh --config .claude/​agent-config.json

Step 8: Emit Signal

[SIGNAL:AGENTS_CONFIGURED]
[ACTIVATE:SPEC_GEN_V1]

Agent Invention

If during any phase, specialized expertise is needed:

1. Detect Gap: Skill recognizes missing expertise
2. Propose Agent: Generate agent definition

---
name: websocket-expert
domain: realtime
role: expert
model: sonnet
description: Real-time WebSocket communication specialist.
tools:
  - Read
  - Write
  - Edit
  - Bash
---

You are an expert in WebSocket and real-time communication...

1. Save: Write to .claude/​agents/​custom/​websocket-expert.md
2. Register: Update agent-config.json
3. Offer Contribution:

New agent created: websocket-expert

Would you like to contribute this agent to the upstream community repo?
[Y] Yes - create PR to turbobeest/​agents (upstream)
[N] No - keep local only

Completion

Outputs:

• .claude/​agent-config.json — Configuration
• .claude/​agents/ — Downloaded agents
• .claude/​.signals/​AGENTS_CONFIGURED.json — Signal

Next phase: Specification (Phase 6)