When extending Claude, Skills and Agents are easy to confuse. Their fundamental difference is context: a Skill loads instructions into your current conversation, while an Agent works independently in an isolated context and returns only the result.
When extending Claude, Skills and Agents are easy to confuse. Both look like ways to make Claude able to do more, but underneath they are very different. Remember the fundamental difference in one word: context. A Skill puts instructions into your current conversation. An Agent works in an isolated context and returns only the conclusion.
1. What Are Skills?
A Skill is a reusable instruction / knowledge module. In practice, it is a Markdown file (SKILL.md) placed under .claude/skills/, containing a fixed process or domain knowledge, such as “how to write good commit messages” or “how to review a PR.”
- Triggering: Claude can load Skills automatically by relevance; user-visible Skills may also appear as slash commands such as
/commitor/review-pr. - Execution: Skills run inline in the current conversation, sharing the same context.
- Use case: package standard workflows, best practices, and domain knowledge for on-demand use.
Key feature: progressive disclosure. A Skill usually contributes only a short description to the context. Claude reads the full
SKILL.mdonly when the task is relevant. This lets you keep many Skills available without wasting context.
2. What Are Agents?
An Agent is an independently running sub-Claude instance with its own isolated context window. The main Claude delegates a task through the Agent tool. The subagent reads files, calls tools, reasons, and finally returns a conclusion to the main conversation.
- Triggering: started by the main Claude through an Agent tool.
- Execution: runs independently, can run in parallel, and can work in the background.
- Use case: complex, time-consuming, parallelizable tasks such as deep code exploration, multi-file search, or parallel research.
Key feature: context isolation. If a subagent reads 50 files, that process noise does not flood the main context. The main Claude receives only the conclusion. This keeps the main conversation clean and allows true parallelism.
3. Core Differences
| Skills | Agents / subagents | |
|---|---|---|
| Context | Shared with current conversation | Independent isolated context |
| Execution | Inline and immediate | Async, can run in parallel |
| Who executes | Current Claude instance | Independent sub-Claude instance |
| Return value | Directly changes current conversation behavior | Returns a summary / conclusion |
| Typical use | Standard workflows such as commits and reviews | Delegated investigation, parallel work, deep exploration |
| What it changes | What the current context knows / how it behaves | Who works, and where |
Remember the last row: a Skill changes what this Claude knows; an Agent sends work to another Claude in another place.
4. Context Model Comparison
flowchart TB
subgraph SK["Skill: loaded into current context"]
direction LR
C1["Main conversation context"] -->|"load SKILL.md when needed"| C1b["Main conversation context
(now includes instructions)"]
end
subgraph AG["Agent: separate isolated context"]
direction LR
M["Main conversation context"] -->|"delegate task"| S["Subagent
isolated context
calls tools / reads files"]
S -->|"returns conclusion only"| M2["Main conversation context
(only conclusion added)"]
end
style C1b fill:#dbe9ff,stroke:#2563eb
style S fill:#ffe9d5,stroke:#b71d18
style M2 fill:#d6f5e3,stroke:#1f9e57
- A Skill adds instructions to the current context.
- An Agent isolates the work in another context and returns only the finished result.
5. How to Choose
flowchart TD
Q["I want to extend Claude"] --> A{"Is this a fixed
workflow / knowledge module?"}
A -->|"Yes"| SK["Use a Skill
package it as reusable instructions"]
A -->|"No"| B{"Is the task heavy,
context-consuming,
or parallelizable?"}
B -->|"Yes"| AG["Use an Agent
delegate to an isolated instance"]
B -->|"No"| INLINE["Just say it in the conversation
no abstraction needed"]
style SK fill:#dbe9ff,stroke:#2563eb
style AG fill:#ffe9d5,stroke:#b71d18
Scenario comparison:
| What you want | Use | Why |
|---|---|---|
| Standardize team commit messages | Skill | Fixed pattern, best run inline |
| Review every PR with the same checklist | Skill | Standard workflow, highly reusable |
| Explore how a feature works in a large repo | Agent | Reads many files; isolation keeps main context clean |
| Investigate three independent modules at once | Agent | Parallel work reduces wall-clock time |
| Rename a variable once | Neither | Just ask directly; do not create an abstraction for one-off work |
6. They Can Be Combined
Skills and Agents are not mutually exclusive. They can stack:
- Agents can use Skills: a delegated code-review agent can still load a
/review-prSkill internally. - Skills can direct Claude to spawn Agents: a Skill can say, “when there are N independent subtasks, delegate them to parallel subagents.”
In other words: Skills define how to do something; Agents decide who does it and where. They are orthogonal and can combine into stronger workflows. For multi-agent parallel development, see Multi-Agent Parallel Development with Git Worktree.
7. The Bigger Picture: Three Extension Axes
Extending Claude has three orthogonal axes:
| Extension | What it provides | One sentence |
|---|---|---|
| Skills | Knowledge / process | Let it know how to do something |
| Agents | Delegation / isolation | Let it split work out and run in parallel |
| MCP | External tools / data | Let it access your systems and APIs |
They are often used together: connect your project through MCP, package your review process as a Skill, then delegate large work to Agents.
One-Sentence Summary
Skills are like an operating manual: open it when needed and follow it inline in the current work. Agents are like assistants you send out: give them a task, they work elsewhere, and return only the result.
The choice is simple: use Skills to package “how to do it”; use Agents to delegate “who does it and where.” The strongest pattern is combining them: assistants who know how to use the manual, working in parallel.
