Skip to content
Skillpedia
PT
Tasks & projects41k · #4799

team-composition-patterns

Helps your agent pick the best team of agents for a task. Lets you decide how many agents to use and which types are best suited for the job.

What it does

This tool helps you assemble the best team of AI assistants for a task. It suggests how many assistants to use and which types are most suitable for the job, such as code review, debugging, or creating new features.

When to use it

  • ✓When deciding how many assistants are needed for a task.
  • ✓When choosing between different types of pre-defined teams (review, debug, feature).
  • ✓When selecting the right type of assistant for each role, ensuring they have the correct tools.

Example of what to ask your AI

“I need to create a new feature involving both front-end and back-end. What kind of team should I assemble?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/wshobson/agents/blob/main/plugins/agent-teams/skills/team-composition-patterns/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/wshobson/agents/blob/main/plugins/agent-teams/skills/team-composition-patterns/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
View on GitHub ↗Raw file
How it works

The tool uses simple rules based on task complexity to suggest team size. It also offers ready-made configurations for common job types and guides on which assistant type (with specific tools) to use for each role.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add wshobson/agents --skill team-composition-patterns

Or download just the file:

curl -L https://raw.githubusercontent.com/wshobson/agents/main/plugins/agent-teams/skills/team-composition-patterns/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Team Composition Patterns

Best practices for composing multi-agent teams, selecting team sizes, choosing agent types, and configuring display modes for Claude Code's Agent Teams feature.

When to Use This Skill

  • Deciding how many teammates to spawn for a task
  • Choosing between preset team configurations
  • Selecting the right agent type (subagent_type) for each role
  • Configuring teammate display modes (tmux, iTerm2, in-process)
  • Building custom team compositions for non-standard workflows

Team Sizing Heuristics

Complexity Team Size When to Use
Simple 1-2 Single-dimension review, isolated bug, small feature
Moderate 2-3 Multi-file changes, 2-3 concerns, medium features
Complex 3-4 Cross-cutting concerns, large features, deep debugging
Very Complex 4-5 Full-stack features, comprehensive reviews, systemic issues

Rule of thumb: Start with the smallest team that covers all required dimensions. Adding teammates increases coordination overhead.

Preset Team Compositions

Review Team

  • Size: 3 reviewers
  • Agents: 3x team-reviewer
  • Default dimensions: security, performance, architecture
  • Use when: Code changes need multi-dimensional quality assessment

Debug Team

  • Size: 3 investigators
  • Agents: 3x team-debugger
  • Default hypotheses: 3 competing hypotheses
  • Use when: Bug has multiple plausible root causes

Feature Team

  • Size: 3 (1 lead + 2 implementers)
  • Agents: 1x team-lead + 2x team-implementer
  • Use when: Feature can be decomposed into parallel work streams

Fullstack Team

  • Size: 4 (1 lead + 3 implementers)
  • Agents: 1x team-lead + 1x frontend team-implementer + 1x backend team-implementer + 1x test team-implementer
  • Use when: Feature spans frontend, backend, and test layers

Research Team

  • Size: 3 researchers
  • Agents: 3x general-purpose
  • Default areas: Each assigned a different research question, module, or topic
  • Capabilities: Codebase search (Grep, Glob, Read), web search (WebSearch, WebFetch)
  • Use when: Need to understand a codebase, research libraries, compare approaches, or gather information from code and web sources in parallel

Security Team

  • Size: 4 reviewers
  • Agents: 4x team-reviewer
  • Default dimensions: OWASP/vulnerabilities, auth/access control, dependencies/supply chain, secrets/configuration
  • Use when: Comprehensive security audit covering multiple attack surfaces

Migration Team

  • Size: 4 (1 lead + 2 implementers + 1 reviewer)
  • Agents: 1x team-lead + 2x team-implementer + 1x team-reviewer
  • Use when: Large codebase migration (framework upgrade, language port, API version bump) requiring parallel work with correctness verification

Agent Type Selection

When spawning teammates with the Agent tool, choose subagent_type based on what tools the teammate needs:

Agent Type Tools Available Use For
general-purpose All tools (Read, Write, Edit, Bash, etc.) Implementation, debugging, any task requiring file changes
Explore Read-only tools (Read, Grep, Glob) Research, code exploration, analysis
Plan Read-only tools Architecture planning, task decomposition
agent-teams:team-reviewer Read/search/Bash plus TaskList/TaskGet/TaskUpdate/SendMessage Code review with structured findings
agent-teams:team-debugger Read/search/Bash plus TaskList/TaskGet/TaskUpdate/SendMessage Hypothesis-driven investigation
agent-teams:team-implementer Read/Write/Edit/search/Bash plus TaskList/TaskGet/TaskUpdate/SendMessage Building features within file ownership boundaries

…

FAQ

What are 'team sizing heuristics'?

These are practical rules for deciding how many assistants to use. For example, simple tasks might need 1-2 assistants, while very complex tasks might need 4-5.

What are 'preset team compositions'?

These are pre-assembled team templates for common tasks, like a 'Review Team' to check code or a 'Debug Team' to find bugs.

Why is it important to choose the correct 'agent type'?

Each assistant type has different tools. Choosing the right type ensures the assistant has the necessary permissions and tools to perform its role, such as writing code or just reading information.

Details

Original description by the author

Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection. Use this skill when deciding how many agents to spawn for a task, when choosing between a review team versus a feature team versus a debug team, when selecting the correct subagent_type for each role to ensure agents have the tools they need, when configuring display modes (tmux, iTerm2,

repo: wshobson/agents

Popularity

GitHub stars
41k
Ranking position
#4799
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Misc41k

screen-reader-testing

Has your agent test websites using screen readers to ensure they are accessible.

wshobson/agents

Misc41k

wcag-audit-patterns

Helps your agent audit websites for accessibility and fix issues according to WCAG guidelines.

wshobson/agents

Tasks & projects41k

multi-reviewer-patterns

Enables your agent to coordinate parallel code reviews, deduplicating findings and consolidating reports.

wshobson/agents

Tasks & projects41k

parallel-debugging

Allows the agent to debug complex issues with parallel investigations and root cause analysis.

wshobson/agents

Similar skills

Tasks & projects280k

carrier-relationship-management

Manages relationships with carriers. It helps negotiate freight rates, evaluate performance, and build transportation strategies.

affaan-m/ECC

Tasks & projects280k

cost-tracking

Tracks and reports agent token usage and costs. It's useful for efficiently controlling spending and budgets.

affaan-m/ECC

Tasks & projects280k

plan-canvas

Opens plans and artifacts in a browser window for you to comment on. It makes giving visual feedback on needed changes easier.

affaan-m/ECC