team-composition-patterns
by wshobsonteam-composition-patterns is a decision skill for designing multi-agent teams in Claude Code Agent Teams, with sizing heuristics, subagent_type selection, and display mode guidance. Use this team-composition-patterns guide to apply preset review/debug teams, choose roles, and standardize team setup across tasks.
This skill scores 78/100, meaning it is a solid listing candidate with good operational guidance; directory users can decide to install it, though they should expect to apply the guidance manually rather than via automated setup.
- Clear triggerability with explicit 'When to Use This Skill' scenarios and sizing heuristics for team composition.
- Actionable decision support via the agent-type selection matrix and capability table for choosing subagent_type.
- Concrete preset team configurations and task templates (e.g., review/debug teams) that reduce guesswork for common workflows.
- No install or quick-start command in SKILL.md, so adoption requires manual interpretation of the guidance.
- Some operational details appear truncated in excerpts, which may require users to read the full files for complete instructions.
Overview of team-composition-patterns skill
team-composition-patterns is a decision skill for designing multi-agent teams in Claude Code Agent Teams, covering team size heuristics, agent type selection, and display mode choices. It’s best for builders who need repeatable team setups for review, debugging, or feature delivery rather than ad‑hoc “spawn a few agents” prompts.
What the team-composition-patterns skill helps you decide
It answers three adoption blockers: how many agents to use, which subagent_type fits each role, and which display mode works in your environment (tmux, iTerm2, in‑process).
Best-fit scenarios and outcomes
Use it when you need consistent team composition across tasks like code review, bug investigation, or feature implementation, and when you want preset teams you can reuse rather than rethinking roles each time.
Differentiators vs generic prompts
Unlike generic “create a team” prompts, the skill codifies size heuristics, preset configurations, and a decision matrix for subagent_type selection tied to agent capabilities.
When it is not a fit
If you are not using Claude Code Agent Teams or you only ever need a single assistant for simple tasks, this skill adds overhead without clear benefit.
How to Use team-composition-patterns skill
team-composition-patterns install and entry point
Install the skill with: npx skills add https://github.com/wshobson/agents --skill team-composition-patterns. The core guidance lives in plugins/agent-teams/skills/team-composition-patterns/SKILL.md.
Read these files first for adoption decisions
Start with SKILL.md, then read references/agent-type-selection.md for the subagent_type decision matrix and references/preset-teams.md for ready-made team setups and task templates.
Inputs the skill expects you to provide
Provide the task type (review/debug/feature/migration), complexity level, constraints (CI vs local), and whether agents need write access. These directly map to team size and subagent_type choices.
Turn a rough goal into a strong prompt
Weak: “spawn a team to review this PR.”
Strong: “Review 6-file diff touching auth and caching; prioritize security and performance; local dev; need file:line findings and fixes.” This lets the skill pick a review team preset and reviewer dimensions.
Use team sizing heuristics to avoid over/under-spawning
Match task complexity to team size: simple (1–2), moderate (2–3), complex (3–4+). Larger teams help when multiple dimensions matter (security + performance + architecture), not just big code volume.
Use the agent type decision matrix
Use references/agent-type-selection.md to choose subagent_type. Example: code review → agent-teams:team-reviewer; bug investigation → agent-teams:team-debugger; architecture exploration without edits → Plan or Explore.
Apply preset team compositions first
The preset team definitions (review/debug) are the fastest path to value. They include member roles, focus areas, and structured task templates so each agent has a clear dimension and output format.
Choose display mode based on environment
If you need multiple concurrent outputs and can handle terminal panes, tmux is recommended. For lighter setups, iTerm2 or in‑process output can reduce friction.
Suggested workflow for team-composition-patterns usage
- Classify the task and complexity.
- Select a preset team or custom team based on dimensions.
- Assign subagent_type for each role.
- Choose display mode for your environment.
- Provide a structured task template to each teammate.
team-composition-patterns skill FAQ
Is the team-composition-patterns skill only for Claude Code Agent Teams?
Yes. It is designed around Agent Teams concepts like subagent_type and display modes. Without that environment, the guidance is less actionable.
How is it different from a normal “create a team” prompt?
It gives decision rules for team size, a matrix for agent type selection, and specific preset teams with task templates—elements a generic prompt usually lacks.
Is this beginner-friendly?
Yes, if you follow the preset teams. The decision matrix can feel dense, but it prevents common mistakes like assigning write permissions to an exploration agent.
When should I avoid using it?
Avoid it for one-off, low-risk tasks where a single general-purpose agent is enough. The coordination overhead may outweigh benefits.
Does it support custom workflows like migrations or audits?
Yes. The skill explicitly covers non-standard workflows; you build a custom team composition by combining dimensions and selecting appropriate subagent_type roles.
How to Improve team-composition-patterns skill
Provide clearer task dimensions for better team design
Specify review dimensions (security, performance, architecture, testing). Clear dimensions let the skill map to preset reviewer roles and reduce overlap.
Avoid common failure modes
Failure mode: choosing the wrong subagent_type (e.g., Plan for a task requiring edits). Fix it by stating whether the agent must write files and by using the decision matrix.
Use stronger input context to improve outputs
Include scope indicators like “multi-file change,” “cross-cutting concern,” or “CI-only environment.” These change recommended team size and display mode.
Iterate after the first team suggestion
If results feel shallow, add a missing dimension (e.g., accessibility), or increase team size by one. If responses are redundant, reduce team size or narrow scope.
Create a reusable template for your org
Adapt the preset task templates in references/preset-teams.md to your repo conventions (file paths, output format, severity levels). This turns the team-composition-patterns guide into a reliable internal workflow.
Use team-composition-patterns for Agent Orchestration decisions
When coordinating multiple concurrent tasks, use the skill to standardize roles and capabilities, ensuring the right mix of reviewer, debugger, implementer, and lead agents for each stream.