By Remco Livain in AI — 30 May 2026

Claude Skills vs Claude Agents: the difference that actually matters

A Skill is a recipe Claude pulls off the shelf. An Agent is a coworker you delegate a whole job to. Here's the operator-level explanation — and why the real difference is memory, not power.

Every other week now, a founder asks me some version of the same question. They've started using Claude seriously, they keep seeing the words Skill and Agent thrown around in the same sentence, and they want to know whether they're the same thing dressed up in different clothes.

They're not. And once you see the difference clearly, you stop wasting hours building the wrong thing.

So this is the short, operator-level explanation I now send people. No code, no jargon — just the mental model I use when I'm deciding which one to reach for inside a client engagement.

A Skill is a recipe. An Agent is a coworker.

The cleanest way to hold these in your head: a Skill is a reusable playbook Claude pulls off the shelf when it recognises a task. An Agent is an autonomous worker you hand a job to and let get on with it in the back room.

A Skill is a small folder — a SKILL.md file plus any scripts or templates it needs — that teaches Claude exactly how to do a specific, repeatable thing. Convert this messy spreadsheet. Apply our brand guidelines. Sort this scanned mail into the right entity folder. Anthropic describes them as "organized folders of instructions, scripts, and resources that agents can discover and load dynamically."

An Agent — or subagent, in Claude Code — is a separate Claude instance you delegate a whole task to. It gets its own system prompt, its own tool access, and crucially, its own 200K-token context window. You don't babysit it. It works, it reports back, it disappears.

Why the memory thing actually matters

This is the part most people miss, and it's the most important one.

A Skill lives inside your current conversation. When Claude activates a Skill, it loads those instructions into the same context window you're already working in. You can ask follow-up questions about what it did. You can see the raw output. You stay close to the work.

An Agent lives in its own separate conversation. The parent Claude hands off a task, the agent runs in an isolated context, and only the final summary comes back. All the noise — the file reads, the failed attempts, the verbose tool output — stays in the agent's head, not yours.

If a Skill is a recipe Claude keeps on the shelf and pulls down when someone orders that dish, an Agent is a temporary sous chef you point at a messy station and tell to bring back a finished platter.

That distinction sounds technical. It isn't. It's the whole game when you're running real work through these systems.

Progressive disclosure is the unsexy magic

Skills use a principle called progressive disclosure. Claude pre-loads only the skill's name and one-line description into its system prompt — not the body, not the scripts, not the templates. It reads the heavy stuff only when it decides the current task actually needs it.

The practical consequence: each installed Skill costs only 30 to 50 tokens of startup overhead. Teams run twenty or fifty of them at once without noticeable cost or slowdown. You can pile on the playbooks. Claude only reaches for the right one.

This is why Skills feel cheap and Agents feel expensive. A Skill is a card in your deck. An Agent is a whole separate game getting played in the other room.

When I reach for which

The decision tree I actually use, in plain language:

If the task is a specific, repeatable procedure — convert this file, follow this style guide, format this report, apply these brand rules — that's a Skill. The work is small, the steps are known, and I want it to happen the same way every time. I built one for sorting my scanned mail. I built another for publishing to this blog. They run in seconds, in the same chat, and I see exactly what they did.

If the task is a messy multi-step job that will generate a lot of intermediate noise — refactor this codebase, research this topic across forty sources, audit this ad account — that's an Agent. I don't want a thousand tool calls clogging my main conversation. I want the agent to go away, do the work, and hand me back a clean answer.

The mistake I see people make: they reach for an Agent when a Skill would do, because Agents sound more powerful. They aren't. They're just more isolated. Spinning up an autonomous worker for a five-step task is like hiring a temp to make you a sandwich.

The real power is stacking them

The interesting move isn't choosing between them. It's combining them.

You deploy an Agent for the heavy lift — say, a deep audit across a sprawling Meta ad account, the kind of thing I wrote about a few weeks back — so the thousands of lines of insights traffic stay out of your main chat. Inside that agent's isolated workspace, it dynamically calls Skills: your campaign-naming convention, your reporting template, your bid-strategy guardrails. Each Skill enforces consistency. The Agent provides parallelism and cleanliness.

That's the architecture worth understanding. Not "which one is better." The answer is always "both, used for what they're good at."

What this means if you're not a developer

Most of my clients aren't shipping code. They're running brands, agencies, finance teams. And the question they really want answered is: does any of this matter to me, or is this engineer cosplay?

It matters. Skills are how you stop re-explaining your style guide, your brand voice, your reporting format, your file-naming convention every single time. You write it down once, in a folder, and Claude reaches for it automatically when the task lines up. The same way a good fractional executive stops re-teaching the team how the company does things by writing the playbook down.

Agents are how you stop your AI workspace from turning into a junk drawer. You delegate the messy investigation, the long research, the multi-file edit — and you keep your own head clear.

Both are, in the end, the same trick I keep coming back to: the leverage is the judgement, not the tool. Knowing which one to reach for, and when, is the operator skill that compounds.

The tools are getting cheap. Knowing what to ask of them is not.

Sources & further reading

External
Anthropic — Equipping agents for the real world with Agent Skills
Claude API Docs — Agent Skills overview
Claude Code Docs — Create custom subagents
Simon Willison — Claude Skills are awesome, maybe a bigger deal than MCP