Claude-skill-registry agent-selector

install

source · Clone the upstream repo

git clone https://github.com/majiayu000/claude-skill-registry

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/majiayu000/claude-skill-registry "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data/agent-selector" ~/.claude/skills/majiayu000-claude-skill-registry-agent-selector && rm -rf "$T"

manifest: skills/data/agent-selector/SKILL.md

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:

Tech	Agent
TypeScript	`typescript-pro`
Python	`python-pro`
Next.js	`nextjs-expert`
React	`reactjs-expert`
FastAPI	`python-pro` (covers FastAPI)
PostgreSQL	`sql-pro`
Neo4j	`neo4j-expert`
AWS	`aws-expert`
Docker	`docker-expert`
Kubernetes	`kubernetes-expert`
Terraform	`terraform-expert`

Step 3: Determine Security Level

From PRD Section 11 (Security Requirements):

Level	Additional Agents
Standard	`security-auditor`
High	`security-auditor` , `penetration-tester`
Compliance	`security-auditor` , `compliance-checker`
Financial	All security + `compliance-checker`

Step 4: Check Scale Requirements

From PRD Section 6 (Non-Functional Requirements):

Requirement Additional Agents

High Performance

performance-engineer

cache-expert

Large Data

data-engineer

database-optimizer

Real-time

performance-engineer

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:

Detect Gap: Skill recognizes missing expertise
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...

Save: Write to

.claude/agents/custom/websocket-expert.md

Register: Update agent-config.json
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)