Documentation > Tutorials > Skills vs Agents vs Teams

Guide ID	T-2
Audience	All users
Prerequisites	GS-2: Core Concepts
Time	12 minutes
Difficulty	Beginner

Skills vs Agents vs Teams

GSD Skill Creator provides three levels of abstraction for organizing knowledge: Skills, Agents, and Teams. Each level serves a different purpose and scale of coordination. Understanding when to use each one prevents over-engineering simple tasks and under-powering complex ones.

Comparison Table

Aspect	Skill	Agent	Team
What it is	A single knowledge unit	Composite expertise from multiple skills	Coordinated group of agents
Storage	.claude/skills/name/SKILL.md	.claude/agents/name.md	.claude/teams/name.json
Scale	One domain or pattern	Related skill cluster (2-5 skills)	Parallel or sequential multi-agent work
Creation	skill-creator create	skill-creator agents suggest	skill-creator team create
Trigger	Context matching (automatic)	Delegation by Claude	Explicit invocation
Complexity	Low	Medium	High

Skills: Single Knowledge Units

A skill is the fundamental building block. It encapsulates one domain of knowledge or one workflow pattern. Skills activate automatically when Claude detects a matching context, loading their content into the conversation without any manual action from you.

Use a skill when:

• You have a single, well-defined domain (e.g., "TypeScript patterns" or "git commit conventions")
• The knowledge fits comfortably in one file (under 15,000 characters)
• You want automatic activation based on context matching
• The task is self-contained and does not require coordination with other knowledge

Skills are created with skill-creator create and managed through the standard lifecycle: create, validate, test, and refine.

Agents: Composite Expertise

An agent bundles multiple related skills into a unified persona that Claude can adopt. Agents emerge naturally when the system detects that certain skills consistently activate together. For example, if your TypeScript skill, React skill, and testing skill always fire in the same sessions, the system may suggest a "TypeScript-React-Testing" agent.

Use an agent when:

• Multiple skills always activate together (the system tracks this as co-activation)
• You want a specialized persona with specific tool permissions and model settings
• The combined expertise is richer than any individual skill
• You want to delegate a category of work to a focused specialist

Agents can specify a model (sonnet, opus, haiku), tool permissions, permission modes, and which skills to preload. They are created from the agent suggestion pipeline: skill-creator agents suggest.

Teams: Coordinated Groups

Teams coordinate multiple Claude Code agents working together on complex tasks. While a single agent handles tasks sequentially, teams enable parallel or pipelined work across multiple agents with different specializations.

Teams support three topology patterns:

• Leader-worker: One coordinator agent distributes work to specialist workers and synthesizes their results. Best for parallel research or investigation tasks.
• Pipeline: Agents process work sequentially, each stage feeding into the next. Best for transformation workflows like data collection, analysis, and reporting.
• Swarm: Peer agents work in parallel with a lightweight coordinator. Best for tasks where multiple perspectives are equally valuable.

Use a team when:

• The task is too large or multifaceted for a single agent
• Different parts of the task require different models or tool permissions
• You need parallel processing across multiple dimensions
• The work follows a natural pipeline or leader-worker structure

GSD Skill Creator includes two built-in team templates: a Research Team (5 members, leader-worker, for parallel ecosystem research) and a Debugging Team (4 members, leader-worker, for adversarial debugging).

Example Scenario: Progressive Scaling

Consider a developer working on a TypeScript React application:

• Week 1: They create three individual skills: typescript-patterns, react-hooks, and jest-testing. Each skill activates independently when relevant.
• Week 3: The system detects that all three skills co-activate in 80% of sessions. It suggests creating a composite agent called typescript-react-testing that bundles all three.
• Week 5: A large feature requires researching multiple libraries, writing code, and running comprehensive tests. The developer creates a leader-worker team with the composite agent as a worker alongside a research specialist.

This progression from skills to agents to teams is natural and data-driven. You do not need to plan the entire hierarchy upfront — it emerges from your actual usage patterns.

Decision Guide

When deciding which level to use, ask these questions:

• Is it one domain? Use a skill.
• Do multiple domains always activate together? Let the system suggest an agent.
• Does the task need parallel or sequential multi-agent coordination? Create a team.
• Not sure? Start with skills. The system will suggest agents when co-activation patterns emerge.

What's Next

• Creating Agent Teams — Hands-on tutorial for creating and validating multi-agent teams
• Architecture — Deep dive into the system architecture behind skills, agents, and teams