Claude Skills vs MCP tools: pick the right extension point

Anthropic shipped Claude Skills in March 2026 and developers now hit the same question every week: is this task a Skill or an MCP tool? The docs treat them as complementary, but that leaves the wiring decision on you. Pick wrong and you either stuff prompts with data the model cannot act on, or you build a server to host instructions that belong in a markdown file.

The short version: Skills teach the model how to think about a task. MCP tools let the model do things outside itself. Below is a concrete mental model, seven selection criteria, and working code for both paths.

The split: context vs. action

A Skill is a folder that lives on disk. It contains a SKILL.md with a trigger description, a workflow, optional reference docs, and optional scripts. Claude loads the Skill into context when the user's request matches. Nothing runs over the network.

An MCP tool is a server-side function Claude calls at runtime. You register a schema, the model invokes the tool by name, and your server responds with JSON. The result flows back into the conversation.

One shapes the model's reasoning. The other performs the work. You will often ship both, and they reference each other.

Seven criteria for picking one

Criterion	Choose a Skill	Choose an MCP tool
Needs real-time data	No	Yes
Has side effects (writes, sends)	No	Yes
Requires secrets at call time	No	Yes
Codifies style, policy, or workflow	Yes	No
Output is deterministic code	No	Yes
Response fits in the prompt budget	Yes	Either
Auditor needs a call log	No	Yes

Row by row: if the task needs fresh data (DNS, prices, inventory) you need a tool. If you want Claude to follow a 12-step review checklist, write a Skill. If the work runs database migrations, it has to be a tool with an audit trail. The boundary is clearer once you stop thinking of them as alternatives.

A Skill that points at an MCP server

A Skill can tell Claude which MCP tools to reach for. That pattern is the default for production systems. The Skill holds the workflow and the rules; the MCP server executes.

SKILL.md

# api-lookups-skill/SKILL.md
---
name: api-lookups
description: Use when the user asks about DNS, SSL, IP geolocation, email deliverability, or other network-level diagnostics. Calls the Botoi MCP server for the actual lookup.
---

## When to reach for this Skill

Trigger on any of:
- "what are the MX records for ..."
- "is the SSL cert on ... valid"
- "where is this IP located"
- "does this email bounce"

## Workflow

1. Parse the input into a domain or IP.
2. Call the matching Botoi MCP tool (lookup_dns, lookup_ssl, lookup_ip, lookup_email).
3. Show the result in a short table. Do not dump raw JSON.
4. If the result is ambiguous, follow up with a second tool rather than asking the user.

## Rules

- Never guess DNS records from training data. Always call lookup_dns.
- Cache identical calls within a single conversation.
- When an MX lookup returns no records, flag the domain as "does not accept mail".

Put the trigger in the description field. Keep it specific. "Use when the user asks about DNS" routes requests better than "Handles networking tasks".

References the Skill loads on demand

# api-lookups-skill/references/providers.md

## Known good DNS resolvers
- 1.1.1.1 (Cloudflare)
- 8.8.8.8 (Google)
- 9.9.9.9 (Quad9)

## SPF includes you can trust
- _spf.google.com (Workspace)
- include:spf.mailgun.org (Mailgun)
- include:_spf.mx.cloudflare.net (Cloudflare Email Routing)

## When Claude should escalate to the user
- MX lookup returns NXDOMAIN on a known provider domain.
- SSL cert expires in fewer than 7 days on a production hostname.

Reference files stay out of the base prompt. Claude pulls them in when the workflow needs them. A 2,000-line provider list costs nothing when the user asks about JSON parsing.

The MCP tool the Skill calls

The Skill references lookup_dns. That tool is declared by the MCP server and invoked at runtime.

Tool schema (server-side)

{
  "name": "lookup_dns",
  "description": "Resolve DNS records for a domain. Returns A, AAAA, MX, TXT, CNAME, NS, SOA records with TTL and query time.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "domain": { "type": "string" },
      "type": { "type": "string", "enum": ["A", "AAAA", "MX", "TXT", "CNAME", "NS", "SOA"] }
    },
    "required": ["domain", "type"]
  }
}

The HTTP call behind it

curl -X POST https://api.botoi.com/v1/dns/lookup \
  -H "Content-Type: application/json" \
  -d '{"domain": "stripe.com", "type": "MX"}'

Structured response Claude sees

{
  "domain": "stripe.com",
  "type": "MX",
  "records": [
    { "value": "aspmx.l.google.com", "priority": 1, "ttl": 300 }
  ],
  "query_time_ms": 8
}

The tool performs the lookup on the 1.1.1.1 resolver and returns the payload. Claude receives the JSON, not the raw DNS wire format. The Skill tells it to render a table instead of dumping the object.

Common mistakes

Stuffing lookup data into a Skill

A reference file with every country dial code is fine. A reference file with every SSL certificate on the internet is not. When the data changes daily or the list is larger than a few hundred rows, move it behind a tool call.

Writing a tool for a checklist

If your "tool" returns a static list of 10 things to check, it is a Skill. Tools cost a round trip. Skills cost nothing at call time.

Duplicating logic in both places

Do not restate tool descriptions inside the Skill prose. Claude reads both and the duplicated wording wastes context. Reference the tool by name, keep the schema in the MCP server.

Forgetting a CLAUDE.md pointer

Skills activate on trigger match. For high-priority rules, also point at the Skill from CLAUDE.md:

// CLAUDE.md
When the user asks a network diagnostic question, load the `api-lookups` Skill
and call the Botoi MCP server configured at https://api.botoi.com/mcp.
Do not answer from memory.

That guarantees Claude loads the Skill on every relevant request, not only when the heuristic matches.

When you only need one

Skill-only is right when

• You want to enforce a code-review checklist across a repo.
• You want to pin a writing style (this post uses stop-slop).
• You want Claude to follow a migration runbook but a human runs the commands.

MCP-only is right when

• You expose internal APIs to an agent that already knows the workflow.
• Your users drive the conversation and rules live in a system prompt.
• You bundle tools for anyone to pick up (Botoi ships 49 tools this way).

A pattern that works

1. Pick the boundary: data or behavior. Data goes behind a tool. Behavior goes into a Skill.
2. Write the MCP server first. Nail the schemas, because the Skill will reference them.
3. Write a Skill that triggers on the user language you want to intercept.
4. Reference the tool names from inside the Skill. Explain when to call each.
5. Add a CLAUDE.md line when the Skill should fire on every matching prompt.
6. Ship a reference folder for static knowledge you want loaded on demand.

Try it with the Botoi MCP server

If you want to pair a Skill with a working MCP server, connect to https://api.botoi.com/mcp. You get 49 tools for DNS, SSL, email validation, JWT, hashing, and more. Write a Skill that picks the right tool for your workflow and you have a two-layer agent without running any infrastructure.

See the 30-second setup for Claude Desktop, Cursor, and VS Code, or browse the API docs for the full endpoint list.