team-builder
affaan-m/everything-claude-code
Interactive menu to compose and dispatch parallel agent teams from your collection
What is team-builder?
Team Builder lets you browse available agents, pick which ones to work on a task, and run them in parallel. Use it when you have multiple agent personas and want to combine their expertise on demand without manual coordination.
- Discovers agents from `claude agents` CLI and local markdown files (flat or subdirectory layouts)
- Presents an interactive domain-based menu to select agents by category or name
- Accepts flexible input: domain numbers, agent names, or natural language queries
- Enforces a 5-agent maximum per team to balance coverage and token efficiency
- Spawns selected agents in parallel and synthesizes their outputs into a unified report
How to install team-builder
npx skills add https://github.com/affaan-m/everything-claude-code --skill team-builder- Agent files must be markdown files with a persona prompt (identity, rules, workflow, deliverables)
- First `# Heading` in each file is used as the agent name; first paragraph as description
- Agents can be organized in subdirectories (domain inferred from folder name) or flat layout (domain inferred from filename prefixes)
How to use team-builder
- 1.Run the skill to trigger the interactive menu
- 2.View available agent domains and their agents
- 3.Select domains by number (e.g., '1,3'), agents by name (e.g., 'security + seo'), or use natural language (e.g., 'all from engineering')
- 4.Describe the task you want the team to work on
- 5.Wait for all agents to run in parallel and review the synthesized report with agreements, conflicts, and next steps
Use cases
- Compose an ad-hoc security + SEO review team for a website launch
- Pick domain-specific agents (Engineering, Marketing, Sales) to evaluate a product decision from multiple angles
- Browse available agents before deciding which personas to activate for a task
- Run a Security Engineer and Software Architect in parallel to review code architecture
- Teams with multiple agent personas or plugins installed
- Developers managing domain-specific agent collections
- Anyone wanting to leverage multiple expert perspectives on a single task without manual setup
team-builder FAQ
Subdirectory layout infers domain from folder names (e.g., `agents/engineering/security-engineer.md`). Flat layout infers domain from filename prefixes; a prefix counts as a domain only if 2+ files share it (e.g., `engineering-security-engineer.md` and `engineering-architect.md` both belong to Engineering). Files with unique prefixes go to General.
Yes. The skill discovers agents via `claude agents` CLI (which includes plugin agents) and merges them with local markdown files. User agents take precedence over plugin agents, which take precedence over built-in agents.
The skill will ask you to narrow down your selection. You can pick specific agents to keep or say 'first 5' to use the first five alphabetically.
No. Agents run independently in parallel, each applying their specialty to the task. Results are then synthesized to highlight agreements, conflicts, and recommended next steps.
The skill notes the failure inline and continues with results from agents that succeeded, presenting a partial report.
Full instructions (SKILL.md)
Source of truth, from affaan-m/everything-claude-code.
name: team-builder description: Interactive agent picker for composing and dispatching parallel teams metadata: origin: community
Team Builder
Interactive menu for browsing and composing agent teams on demand. Works with flat or domain-subdirectory agent collections.
When to Use
- You have multiple agent personas (markdown files) and want to pick which ones to use for a task
- You want to compose an ad-hoc team from different domains (e.g., Security + SEO + Architecture)
- You want to browse what agents are available before deciding
Prerequisites
Agent files must be markdown files containing a persona prompt (identity, rules, workflow, deliverables). The first # Heading is used as the agent name and the first paragraph as the description.
Both flat and subdirectory layouts are supported:
Subdirectory layout — domain is inferred from the folder name:
agents/
├── engineering/
│ ├── security-engineer.md
│ └── software-architect.md
├── marketing/
│ └── seo-specialist.md
└── sales/
└── discovery-coach.md
Flat layout — domain inferred from shared filename prefixes. A prefix counts as a domain when 2+ files share it. Files with unique prefixes go to "General". Note: the algorithm splits at the first -, so multi-word domains (e.g., product-management) should use the subdirectory layout instead:
agents/
├── engineering-security-engineer.md
├── engineering-software-architect.md
├── marketing-seo-specialist.md
├── marketing-content-strategist.md
├── sales-discovery-coach.md
└── sales-outbound-strategist.md
Configuration
Agents are discovered via two methods, merged and deduplicated by agent name:
claude agentscommand (primary) — runclaude agentsto get all agents known to the CLI, including user agents, plugin agents (e.g.everything-claude-code:architect), and built-in agents. This automatically covers ECC marketplace installs without any path configuration.- File glob (fallback, for reading agent content) — agent markdown files are read from:
./agents/**/*.md+./agents/*.md— project-local agents~/.claude/agents/**/*.md+~/.claude/agents/*.md— global user agents
Earlier sources take precedence when names collide: user agents > plugin agents > built-in agents. A custom path can be used instead if the user specifies one.
How It Works
Step 1: Discover Available Agents
Run claude agents to get the full agent list. Parse each line:
- Plugin agents are prefixed with
plugin-name:(e.g.,everything-claude-code:security-reviewer). Use the part after:as the agent name and the plugin name as the domain. - User agents have no prefix. Read the corresponding markdown file from
~/.claude/agents/or./agents/to extract the name and description. - Built-in agents (e.g.,
Explore,Plan) are skipped unless the user explicitly asks to include them.
For user agents loaded from markdown files:
- Subdirectory layout: extract the domain from the parent folder name
- Flat layout: collect all filename prefixes (text before the first
-). A prefix qualifies as a domain only if it appears in 2 or more filenames (e.g.,engineering-security-engineer.mdandengineering-software-architect.mdboth start withengineering→ Engineering domain). Files with unique prefixes (e.g.,code-reviewer.md,tdd-guide.md) are grouped under "General" - Extract the agent name from the first
# Heading. If no heading is found, derive the name from the filename (strip.md, replace hyphens with spaces, title-case) - Extract a one-line summary from the first paragraph after the heading
If no agents are found after running claude agents and probing file locations, inform the user: "No agents found. Run claude agents to verify your setup." Then stop.
Step 2: Present Domain Menu
Available agent domains:
1. Engineering — Software Architect, Security Engineer
2. Marketing — SEO Specialist
3. Sales — Discovery Coach, Outbound Strategist
Pick domains or name specific agents (e.g., "1,3" or "security + seo"):
- Skip domains with zero agents (empty directories)
- Show agent count per domain
Step 3: Handle Selection
Accept flexible input:
- Numbers: "1,3" selects all agents from Engineering and Sales
- Names: "security + seo" fuzzy-matches against discovered agents
- "all from engineering" selects every agent in that domain
If more than 5 agents are selected, list them alphabetically and ask the user to narrow down: "You selected N agents (max 5). Pick which to keep, or say 'first 5' to use the first five alphabetically."
Confirm selection:
Selected: Security Engineer + SEO Specialist
What should they work on? (describe the task):
Step 4: Spawn Agents in Parallel
- Read each selected agent's markdown file
- Prompt for the task description if not already provided
- Spawn all agents in parallel using the Agent tool:
subagent_type: "general-purpose"prompt: "{agent file content}\n\nTask: {task description}"- Each agent runs independently — no inter-agent communication needed
- If an agent fails (error, timeout, or empty output), note the failure inline (e.g., "Security Engineer: failed — [reason]") and continue with results from agents that succeeded
Step 5: Synthesize Results
Collect all outputs and present a unified report:
- Results grouped by agent
- Synthesis section highlighting:
- Agreements across agents
- Conflicts or tensions between recommendations
- Recommended next steps
If only 1 agent was selected, skip synthesis and present the output directly.
Rules
- Dynamic discovery only. Never hardcode agent lists. New files in the directory auto-appear in the menu.
- Max 5 agents per team. More than 5 produces diminishing returns and excessive token usage. Enforce at selection time.
- Parallel dispatch. All agents run simultaneously — use the Agent tool's parallel invocation pattern.
- Parallel Agent calls, not TeamCreate. This skill uses parallel Agent tool calls for independent work. TeamCreate (a Claude Code tool for multi-agent dialogue) is only needed when agents must debate or respond to each other.
Examples
User: team builder
Claude:
Available agent domains:
1. Engineering (2) — Software Architect, Security Engineer
2. Marketing (1) — SEO Specialist
3. Sales (4) — Discovery Coach, Outbound Strategist, Proposal Strategist, Sales Engineer
4. Support (1) — Executive Summary
Pick domains or name specific agents:
User: security + seo
Claude:
Selected: Security Engineer + SEO Specialist
What should they work on?
User: Review my Next.js e-commerce site before launch
[Both agents spawn in parallel, each applying their specialty to the codebase]
Claude:
## Security Engineer Findings
- [findings...]
## SEO Specialist Findings
- [findings...]
## Synthesis
Both agents agree on: [...]
Tension: Security recommends CSP that blocks inline styles, SEO needs inline schema markup. Resolution: [...]
Next steps: [...]
Related skills
More from affaan-m/everything-claude-code and the wider catalog.
security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.
golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.
coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.
frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.
backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.
golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.