The confusion is fair. Both extend what Claude can do, both show up in the same agent loop, and people use the words loosely enough that "skill" and "tool" start to blur together. So let me draw the line clearly. In the Claude Skills vs tools question, a skill teaches Claude how to do a repeatable job, while a tool gives Claude something it can call to take an action or fetch data. One is procedural knowledge. The other is a function you can run.
Once that distinction is clear, most of the confusion clears with it.
What a skill is
An Agent Skill is a folder. At minimum it holds a SKILL.md file with YAML frontmatter (a name and a description) plus a body of instructions, and it can bundle extra markdown, scripts, and reference files. Anthropic's overview describes Skills as "modular capabilities that extend Claude's functionality," packaging "instructions, metadata, and optional resources (scripts, templates) that Claude uses automatically when relevant."
What separates a skill from a long prompt is progressive disclosure. Only the name and description load at startup, roughly 100 tokens per skill. The body loads when Claude decides the skill matches your request, and bundled files load only when something references them. You can install a whole stack of skills and pay almost nothing in context until one of them actually fires. In practice a skill feels closer to an onboarding doc you wrote for a new hire than to anything the model calls directly. For the longer version, see what is a Claude skill.
What a tool is
A tool is a function the model can invoke. You define it with a name, a description, and an input schema. When the request maps to that tool, Claude returns a structured tool_use block with the arguments filled in, your code (or Anthropic's) runs it, and the result goes back into the conversation. The tool use docs put it plainly: "Tool use lets Claude call functions you define or that Anthropic provides. Claude decides when to call a tool based on the user's request and the tool's description, then returns a structured call that your application executes (client tools) or that Anthropic executes (server tools)."
That is function calling. The two terms point at the same mechanism. Claude skills vs tool use, Claude skills vs functions, skill vs function calling: those are all the same underlying question. Do I write instructions, or expose a callable function? Client tools, meaning your custom functions plus schema tools like bash, run in your app. Server tools like web_search run on Anthropic's infrastructure and hand you the result directly.
Claude skills vs tools: the actual difference
Laid out side by side, the split looks like this. This is one of the rare cases where a table genuinely earns its place.
| Skill | Tool | |
|---|---|---|
| What it is | Instructions and resources in a folder | A callable function with a schema |
| What it does | Teaches Claude a procedure | Performs an action or returns data |
| How it activates | Claude reads SKILL.md when relevant | Claude emits a tool_use call |
| Loaded | On demand, in stages | Defined up front in the request |
| Lives | On the filesystem (or uploaded) | In your code or on Anthropic's servers |
The short rule: a skill changes what Claude knows how to do, a tool changes what Claude can reach out and do. A skill that says "validate every invoice against these seven rules, then format the output this way" is procedure. A get_invoice(id) function that pulls a record from your database is a tool. A skill can tell Claude when and how to call that function, but it never becomes the function itself.
How they work together
Skills and tools do not compete for the same job. They sit on different layers, and the better setups lean on both at once.
A skill will often instruct Claude to use tools as part of its procedure. The PDF skill in Anthropic's docs is a clean example: its body tells Claude to run pdfplumber and execute bundled scripts via bash. Bash is the tool. The skill is the playbook for using it.
In Claude Code, skills can carry an allowed-tools field in frontmatter. It pays to be precise here, because the docs are: it grants the listed tools permission to run without prompting while that skill is active, but it does not hard-restrict the pool, and your permission settings still govern everything else. Something like allowed-tools: Bash(git add *) Bash(git commit *) lets a release skill run those git commands without a per-use approval popup. The skill scopes the experience of using tools. It does not become one.
Where MCP fits
The Claude skills vs tools vs MCP version deserves a sentence of its own. MCP, the Model Context Protocol, is an open standard for connecting AI apps to external systems. It is the plumbing that exposes tools and data to the model, described at modelcontextprotocol.io as "a USB-C port for AI applications."
So the layering goes like this. MCP is how a tool reaches the model, a tool is the callable function itself, and a skill is the instructions for doing a job, often by calling those very tools. A skill is not a server. For that comparison drawn out in full, read SKILL.md vs MCP server.
The decision rule
Build a tool when you need Claude to do a discrete thing your code controls: hit an API, write to a database, send an email, query a system. The work is an action with defined inputs and outputs, and you want a structured call you can execute and audit later.
Write a skill when you keep pasting the same instructions, checklist, or multi-step procedure into chat and you want Claude to follow it the same way every time, without you steering each run. Here the work is knowing how rather than reaching out.
Most real workflows want both. The skill holds the procedure and the standards, and the tools are the verbs it calls along the way. If you have also been wondering how skills stack up against subagents, slash commands, and plugins, that gets its own breakdown at skills vs subagents vs slash commands vs plugins.
Writing a clean SKILL.md by hand means getting the frontmatter, the description triggers, and the progressive-disclosure structure right, and that part is genuinely fiddly the first few times you try it. Knack turns a short interview into a finished, Anthropic-format skill folder that runs in Claude Code, the Claude apps, Codex, Cursor, and Gemini CLI.
So once you can answer "is this a procedure or an action?", you already know which one to build.