Lar

Skill

Produtividade e fluxo de trabalho

team-builder

affaan-m/ECC

Navegue pelas perfis de agentes disponíveis e monte equipes ad hoc com até 5 agentes para trabalharem em paralelo em uma tarefa; em seguida, sintetize os resultados deles.

...Expandir tudo

Tempo atualizado 2 de Outubro de 2026

# parallel agents # agent personas # claude agents # markdown files # team composition

Criador de Equipes

Menu interativo para navegar e formar equipes de agentes sob demanda. Funciona com coleções de agentes em estrutura plana ou em subdiretórios de domínio.

Quando usar

Você tem vários perfis de agentes (arquivos Markdown) e deseja escolher quais usar para uma tarefa
Você deseja formar uma equipe ad hoc com membros de diferentes domínios (por exemplo, Segurança + SEO + Arquitetura)
Você deseja ver quais agentes estão disponíveis antes de decidir

Pré-requisitos

Os arquivos de agentes devem ser arquivos Markdown contendo um prompt de perfil (identidade, regras, fluxo de trabalho, entregas). O primeiro # Título é usado como nome do agente e o primeiro parágrafo como descrição.

São suportados tanto layouts planos quanto com subdiretórios:

Layout com subdiretórios — o domínio é inferido a partir do nome da pasta:

agents/
├── engineering/
│   ├── security-engineer.md
│   └── software-architect.md
├── marketing/
│   └── seo-specialist.md
└── sales/
    └── discovery-coach.md

Estrutura plana — o domínio é inferido a partir de prefixos comuns nos nomes dos arquivos. Um prefixo conta como um domínio quando dois ou mais arquivos o compartilham. Arquivos com prefixos exclusivos vão para “Geral”. Observação: o algoritmo divide na primeira “-”, portanto, domínios com várias palavras (por exemplo, gestão-de-produtos) devem usar o layout de subdiretórios:

agents/
├── engenharia-segurança-engenheiro.md
├── engenharia-arquiteto-de-software.md
├── marketing-especialista-em-SEO.md
├── marketing-estrategista-de-conteúdo.md
├── vendas-coach-de-descoberta.md
└── vendas-estrategista-de-contato-ativo.md

Configuração

Os agentes são detectados por meio de dois métodos, mesclados e deduplicados por nome de agente:

comando `claude agents ` (primário) — execute `claude agents` para obter todos os agentes conhecidos pela CLI, incluindo agentes de usuário, agentes de plug-in (por exemplo, ` everything-claude-code:architect`) e agentes integrados. Isso abrange automaticamente as instalações do ECC Marketplace sem qualquer configuração de caminho.
Padrão de arquivo (alternativa, para leitura do conteúdo do agente) — os arquivos Markdown dos agentes são lidos em:
- ./agents/**/*.md + ./agents/*.md — agentes locais do projeto
- ~/.claude/agents/**/*.md + ~/.claude/agents/*.md — agentes globais do usuário

As fontes anteriores têm prioridade em caso de conflito de nomes: agentes de usuário > agentes de plug-in > agentes integrados. Um caminho personalizado pode ser usado se o usuário especificar um.

Como funciona

Etapa 1: Descobrir os agentes disponíveis

Execute o comando ` claude agents ` para obter a lista completa de agentes. Analise cada linha:

Os agentes de plug-in são precedidos pelo prefixo plugin-name: (por exemplo, everything-claude-code:security-reviewer). Use a parte após : como nome do agente e o nome do plug-in como domínio.
Os agentes de usuário não têm prefixo. Leia o arquivo Markdown correspondente em ~/.claude/agents/ ou ./agents/ para extrair o nome e a descrição.
Agentes integrados (por exemplo, Explore, Plan) são ignorados, a menos que o usuário solicite explicitamente sua inclusão.

Para agentes de usuário carregados a partir de arquivos Markdown:

Estrutura de subdiretórios: extraia o domínio a partir do nome da pasta pai
Estrutura plana: colete todos os prefixos de nomes de arquivos (texto antes do primeiro -). Um prefixo só se qualifica como domínio se aparecer em dois ou mais nomes de arquivos (por exemplo, engineering-security-engineer.md e engineering-software-architect.md começam ambos com engineering → domínio Engineering). Arquivos com prefixos únicos (por exemplo, code-reviewer.md, tdd-guide.md) são agrupados em “Geral”
Extraia o nome do agente do primeiro # Título. Se nenhum título for encontrado, deduza o nome a partir do nome do arquivo (remova .md, substitua hífens por espaços e coloque em maiúscula a primeira letra de cada palavra)
Extraia um resumo de uma linha do primeiro parágrafo após o título

Se nenhum agente for encontrado após executar o `claude agents` e verificar os locais dos arquivos, informe ao usuário: “Nenhum agente encontrado. Execute o `claude agents` para verificar sua configuração.” Em seguida, interrompa o processo.

Etapa 2: Apresentar o menu de domínios

Domínios de agentes disponíveis:
1. Engenharia — Arquiteto de Software, Engenheiro de Segurança
2. Marketing — Especialista em SEO
3. Vendas — Coach de Descoberta, Estrategista de Vendas Ativas

Escolha domínios ou nomeie agentes específicos (por exemplo, “1,3” ou “segurança + seo”):

Ignore domínios sem agentes (diretórios vazios)
Mostrar o número de agentes por domínio

Etapa 3: Processar a seleção

Aceitar entradas flexíveis:

Números: “1,3” seleciona todos os agentes das áreas de Engenharia e Vendas
Nomes: “security + seo” faz uma correspondência aproximada com os agentes encontrados
“todos da Engenharia” seleciona todos os agentes nesse domínio

Se mais de 5 agentes forem selecionados, liste-os em ordem alfabética e peça ao usuário para refinar a seleção: “Você selecionou N agentes (máximo de 5). Escolha quais manter ou diga ‘primeiros 5’ para usar os cinco primeiros em ordem alfabética.”

Confirme a seleção:

Selecionados: Engenheiro de Segurança + Especialista em SEO
No que eles devem trabalhar? (descreva a tarefa):

Etapa 4: Gerar agentes em paralelo

Leia o arquivo Markdown de cada agente selecionado
Solicite a descrição da tarefa, caso ainda não tenha sido fornecida
Inicie todos os agentes em paralelo usando a ferramenta Agent:
- subagent_type: "general-purpose"
- prompt: "{conteúdo do arquivo do agente}\n\nTarefa: {descrição da tarefa}"
- Cada agente é executado de forma independente — não é necessária comunicação entre os agentes
Se um agente falhar (erro, tempo limite excedido ou saída vazia), registre a falha no próprio texto (por exemplo, “Engenheiro de Segurança: falha — [motivo]”) e continue com os resultados dos agentes que foram bem-sucedidos

Etapa 5: Sintetizar os resultados

Reúna todas as saídas e apresente um relatório unificado:

Resultados agrupados por agente
Seção de síntese destacando:
- Pontos de concordância entre os agentes
- Conflitos ou tensões entre as recomendações
- Próximas etapas recomendadas

Se apenas 1 agente tiver sido selecionado, pule a síntese e apresente o resultado diretamente.

Regras

Apenas descoberta dinâmica. Nunca codifique listas de agentes. Novos arquivos no diretório aparecem automaticamente no menu.
Máximo de 5 agentes por equipe. Mais de 5 geram retornos decrescentes e uso excessivo de tokens. Aplique essa regra no momento da seleção.
Despacho paralelo. Todos os agentes são executados simultaneamente — use o padrão de invocação paralela da ferramenta Agent.
Chamadas paralelas da ferramenta Agent, não do TeamCreate. Esta habilidade utiliza chamadas paralelas da ferramenta Agent para trabalho independente. O TeamCreate (uma ferramenta do Claude Code para diálogo multiagente) só é necessário quando os agentes precisam debater ou responder uns aos outros.

Exemplos

Usuário: criador de equipe

Claude:
Domínios de agentes disponíveis:
1. Engenharia (2) — Arquiteto de Software, Engenheiro de Segurança
2. Marketing (1) — Especialista em SEO
3. Vendas (4) — Coach de Descoberta, Estrategista de Vendas Ativas, Estrategista de Propostas, Engenheiro de Vendas
4. Suporte (1) — Resumo Executivo

Escolha domínios ou nomeie agentes específicos:

Usuário: segurança + seo

Claude:
Selecionados: Engenheiro de Segurança + Especialista em SEO
No que eles devem trabalhar?

Usuário: Analise meu site de comércio eletrônico em Next.js antes do lançamento

[Os dois agentes são ativados em paralelo, cada um aplicando sua especialidade à base de código]

Claude:
## Conclusões do Engenheiro de Segurança
- [conclusões...]

## Conclusões do Especialista em SEO
- [conclusões...]

## Síntese
Ambos os agentes concordam que: [...]
Conflito: a equipe de segurança recomenda um CSP que bloqueie estilos embutidos, enquanto a equipe de SEO precisa de marcação de esquema embutida. Resolução: [...]
Próximos passos: [...]

Ver no GitHub

---
name: team-builder
description: Browse available agent personas and compose ad-hoc teams of up to 5 agents to work in parallel on a task, then synthesize their results.
---

# 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:

1. **`claude agents` command** (primary) — run `claude agents` to 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.
2. **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.md` and `engineering-software-architect.md` both start with `engineering` → 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

1. Read each selected agent's markdown file
2. Prompt for the task description if not already provided
3. 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
4. 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: [...]
```