Agent skill

Team Composition Patterns

by wshobson in wshobson/agents

Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection.

MITAuto-check passedDevelopment

Install Team Composition Patterns

skills CLI
$ npx skills add wshobson/agents --skill team-composition-patterns -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install wshobson/agents team-composition-patterns --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/wshobson/agents.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/agent-teams/skills/team-composition-patterns .claude/skills/team-composition-patterns && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
team-composition-patterns
GitHub stars
40k
Token cost
~2k tokens
SKILL.md length
783 words
Files
3 (incl. references)
Skills in repo
142
Repo updated
First seen
Licence
MIT

At a glance

Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection.

  • Works in 5 steps: Every team needs a coordinator — Either… → Match roles to agent types — Use… → Avoid duplicate roles — Two agents doing… → …
  • Deciding how many agents to spawn for a task
  • SKILL.md covers When to Use This Skill, Team Sizing Heuristics, Preset Team Compositions and Agent Type Selection, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Team Composition Patterns is an agent skill from wshobson/agents. 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 subagenttype for each role to ensure agents have the tools they need, when configuring display modes (tmux, iTerm2, in-process) for a CI or local environment, or when building a custom team composition for a non-standard workflow such…

Its SKILL.md is about 2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/agent-type-selection.md` and `references/preset-teams.md`).

It sits in Development, covering Design patterns, Security review and Subagents. It works with tmux. The repository describes itself as: Multi-harness agentic plugin marketplace for Claude Code, Codex, Cursor, OpenCode, GitHub Copilot, Google Antigravity, and Pi. The licence is MIT.

When your agent uses it

  • Deciding how many agents to spawn for a task
  • Choosing between a review team versus a feature team versus a debug team
  • Selecting the correct subagenttype for each role to ensure agents have the tools they need
  • Configuring display modes (tmux

Example prompts

  • “/team-composition-patterns”

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Every team needs a coordinator — Either designate a team-lead or have the user coordinate directly
  2. Match roles to agent types — Use specialized agents (reviewer, debugger, implementer) when available
  3. Avoid duplicate roles — Two agents doing the same thing wastes resources
  4. Define boundaries upfront — Each teammate needs clear ownership of files or responsibilities
  5. Keep it small — 2-4 teammates is the sweet spot; 5+ requires significant coordination overhead

What it can do on your machine

Read from SKILL.md and the folder at commit 46891e7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Team Composition Patterns loads about 2k tokens when it runs, and up to ~5.2k if it reads all its reference files. Until then it costs about 145 tokens; SKILL.md has 783 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~145
When it runs · the whole SKILL.md, loaded when a task matches
~2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from wshobson/agents at commit 46891e7, republished under its MIT licence (© wshobson). 783 words, ~2,038 tokens.

Download SKILL.mdSave it as .claude/skills/team-composition-patterns/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
team-composition-patterns
description
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, in-process) for a CI or local environment, or when building a custom team composition for a non-standard workflow such as a migration or security audit.
version
1.0.2

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

ComplexityTeam SizeWhen to Use
Simple1-2Single-dimension review, isolated bug, small feature
Moderate2-3Multi-file changes, 2-3 concerns, medium features
Complex3-4Cross-cutting concerns, large features, deep debugging
Very Complex4-5Full-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 TypeTools AvailableUse For
general-purposeAll tools (Read, Write, Edit, Bash, etc.)Implementation, debugging, any task requiring file changes
ExploreRead-only tools (Read, Grep, Glob)Research, code exploration, analysis
PlanRead-only toolsArchitecture planning, task decomposition
agent-teams:team-reviewerRead/search/Bash plus TaskList/TaskGet/TaskUpdate/SendMessageCode review with structured findings
agent-teams:team-debuggerRead/search/Bash plus TaskList/TaskGet/TaskUpdate/SendMessageHypothesis-driven investigation
agent-teams:team-implementerRead/Write/Edit/search/Bash plus TaskList/TaskGet/TaskUpdate/SendMessageBuilding features within file ownership boundaries
agent-teams:team-leadRead/search/Bash plus Agent Teams coordination toolsTeam orchestration and coordination

Key distinction: Read-only agents (Explore, Plan) cannot modify files. Never assign implementation tasks to read-only agents.

Display Mode Configuration

Configure in ~/.claude/settings.json:

json
{
  "teammateMode": "tmux"
}
ModeBehaviorBest For
"tmux"Each teammate in a tmux paneDevelopment workflows, monitoring multiple agents
"iterm2"Each teammate in an iTerm2 tabmacOS users who prefer iTerm2
"in-process"All teammates in same processSimple tasks, CI/CD environments
Show full SKILL.md (296 more words)Show less

Custom Team Guidelines

When building custom teams:

  1. Every team needs a coordinator — Either designate a team-lead or have the user coordinate directly
  2. Match roles to agent types — Use specialized agents (reviewer, debugger, implementer) when available
  3. Avoid duplicate roles — Two agents doing the same thing wastes resources
  4. Define boundaries upfront — Each teammate needs clear ownership of files or responsibilities
  5. Keep it small — 2-4 teammates is the sweet spot; 5+ requires significant coordination overhead

Troubleshooting

A teammate was spawned as Explore but needs to write files. Explore and Plan are read-only agents. Change the subagent_type to general-purpose or an appropriate specialized agent type. Never assign implementation tasks to read-only agents.

The team is growing too large and coordination is slowing everything down. Each additional teammate adds communication overhead. Consolidate roles: can one agent cover two dimensions? A 4-person team doing 6 independent tasks is usually better served by 3 agents covering 2 tasks each.

tmux mode is not showing panes. Ensure tmux is installed and a session is already running before spawning teammates. The in-process mode works without tmux and is suitable for CI or scripted environments.

Two reviewers are flagging the same issues. The review dimensions overlap. Redefine each reviewer's focus area: one on correctness/logic, one on security, one on performance/scalability. Overlapping coverage wastes tokens and produces duplicate findings.

A team-lead is spawning teammates but they are not receiving tasks. Verify that the lead is using the Agent tool to spawn teammates and passing complete context in the prompt. Teammates start fresh with no prior conversation history — they need all relevant information in their initial prompt.

© wshobson, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in plugins/agent-teams/skills/team-composition-patterns of wshobson/agents.

  • SKILL.md
  • references/agent-type-selection.md
  • references/preset-teams.md

Open the folder on GitHubat commit 46891e7

Compare with similar skills

Team Composition Patterns next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Team Composition Patterns compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Team Composition Patterns this skillwshobson/agents40k—~2kAutomated safety check: PassMIT
Exploreyonatangross/orchestkit288—~3.9kAutomated safety check: NotesMIT
Review SwarmDimillian/Skills4k1 repos~1.6kAutomated safety check: PassMIT
Kickoffopenwpm/OpenWPM1.4k—~781Automated safety check: PassCustom licence
Expert Code ReviewerGulajavaMinistudio/Mayukai-Theme139—~1.4kAutomated safety check: PassMIT
Adversarial TS Patternspproenca/dot-skills214—~1.8kAutomated safety check: PassMIT

Similar skills

  • Explore

    yonatangross/orchestkit

    Multi-angle codebase exploration spawning 3-5 parallel agents for code structure, data flow, architecture patterns, and health assessment.

    288 GitHub stars~3.9k tokensUpdated today
    DevelopmentAuto-check: notes
  • Review Swarm

    Dimillian/Skills

    Parallel read-only multi-agent review of a current git diff or explicit file scope to find behavioral regressions, security or privacy risks, performance or reliability issues, and contract or test…

    4k GitHub starsUsed in 1 repo~1.6k tokens
    Agent WorkflowsAuto-check passed
  • Kickoff

    openwpm/OpenWPM

    A skill your agent uses to launch a background Claude agent in tmux (or docker/podman) to implement a feature end-to-end.

    1.4k GitHub stars~781 tokensUpdated 2 days ago
    DevOps & CloudAuto-check passed
  • Expert Code Reviewer

    GulajavaMinistudio/Mayukai-Theme

    Language-agnostic workflow for code reviews and security audits against Clean Code/SOLID principles, generating formal refactoring plans.

    139 GitHub stars~1.4k tokensUpdated 3 mo ago
    DevelopmentAuto-check passed
  • Adversarial TS Patterns

    pproenca/dot-skills

    A skill your agent uses to gate TypeScript and React application code with a pass/fail adversarial review of design-pattern usage — a single blind reviewer subagent judges a diff or file set against…

    214 GitHub stars~1.8k tokensUpdated 1 mo ago
    DevelopmentAuto-check passed
  • Agent Deck

    asheshgoplani/agent-deck

    agent-deck, the terminal session manager for AI coding agents.

    1k GitHub stars~1.7k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed

More from wshobson/agents

All 142 skills in this repo
  • Cuts cloud spend across AWS, Azure, GCP and OCI with cost tagging, rightsizing, commitment and spot pricing models, and architecture changes.

    40k GitHub starsUsed in 13 repos~1.7k tokens
    Auto-check passed
  • Billing Automation

    wshobson/agents

    Covers building subscription billing: billing cycles, subscription states, invoice generation, proration, tax handling and dunning for failed payments.

    40k GitHub starsUsed in 12 repos~473 tokens
    Auto-check passed
  • Profiles slow Python code with cProfile and memory profilers, then applies targeted fixes for CPU, memory, I/O and query bottlenecks.

    40k GitHub starsUsed in 12 repos~814 tokens
    Auto-check passed
  • Portfolio Risk Metrics

    wshobson/agents

    Covers portfolio risk measurement with VaR, CVaR, Sharpe, Sortino and drawdown, plus guidance on limits, stress tests and tail risk.

    40k GitHub starsUsed in 12 repos~502 tokens
    Auto-check passed
  • Plans memory headroom, works through out-of-memory failures and watches temperature and power during long ML training jobs on NVIDIA DGX Spark.

    40k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed
  • Writes unit tests for shell scripts with Bats: error-condition tests, fixtures and mocks, cross-shell checks, parallel runs, helper files and CI integration.

    40k GitHub starsUsed in 11 repos~1.3k tokens
    Auto-check passed

Works with

Questions about Team Composition Patterns

What does Team Composition Patterns do?

Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection. Team Composition Patterns is an agent skill from wshobson/agents. Design optimal agent team compositions with sizing heuristics, preset configurations, and agent type selection.

When should I use Team Composition Patterns?

Team Composition Patterns fits situations like: deciding how many agents to spawn for a task; choosing between a review team versus a feature team versus a debug team; selecting the correct subagenttype for each role to ensure agents have the tools they need; configuring display modes (tmux.

How do I install Team Composition Patterns in Claude Code?

Run `npx skills add wshobson/agents --skill team-composition-patterns -a claude-code`. Or copy the skill folder (plugins/agent-teams/skills/team-composition-patterns in wshobson/agents) into .claude/skills/team-composition-patterns in your project. Claude Code loads it when a task matches its description.

How do I install Team Composition Patterns in Codex?

Run `npx skills add wshobson/agents --skill team-composition-patterns -a codex`. Or copy the skill folder (plugins/agent-teams/skills/team-composition-patterns in wshobson/agents) into .agents/skills/team-composition-patterns in your project. Codex loads it when a task matches its description.

Can I use Team Composition Patterns in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add wshobson/agents --skill team-composition-patterns -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/team-composition-patterns, .gemini/skills/team-composition-patterns, .github/skills/team-composition-patterns and .opencode/skills/team-composition-patterns in your project.

What does Team Composition Patterns need to run?

SKILL.md names no scripts, command-line tools or credentials: Team Composition Patterns is instructions for the agent only.

Does Team Composition Patterns access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Team Composition Patterns safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Team Composition Patterns use?

Team Composition Patterns is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Team Composition Patterns use?

About 2k tokens (SKILL.md is roughly 8.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.2k tokens, read only when the agent opens those files.

What are the alternatives to Team Composition Patterns?

Skills that share tags, products or a category with Team Composition Patterns: Explore (yonatangross/orchestkit, 288 stars), Review Swarm (Dimillian/Skills, 4k stars), Kickoff (openwpm/OpenWPM, 1.4k stars) and Expert Code Reviewer (GulajavaMinistudio/Mayukai-Theme, 139 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Team Composition Patterns?

wshobson (a GitHub user) maintains it in wshobson/agents, which has 40,254 GitHub stars. The repository holds 142 skills in this directory. The repository was last updated on October 5, 2026.

Source: wshobson/agents on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.