← Learn

Claude Skills vs MCP: When Builders Should Use Each

Claude Skills fit repeatable methods, while MCP fits live access to external systems. Most useful agent workflows use both: MCP provides the connection, while Skill instructions tell the assistant how to use that connection safely and consistently.

In brief: Claude Skills package repeatable instructions in SKILL.md plus optional scripts, references, examples, and templates. MCP exposes tools, resources, and prompts through a protocol an AI client can call. Public agent directories matter when the external capability is an ERC-8004 agent or paid machine service that needs inspection before installation.

Skills carry method, MCP carries access

Start with ownership: a missing repeatable method points to a Skill, while a missing live-system connection points to MCP.

Claude Skills are modular packages that tell Claude how to handle a class of work. Each package has a required SKILL.md file, YAML frontmatter, and optional supporting files such as scripts, references, examples, or templates. Skill content changes how the assistant approaches a task.

Model Context Protocol connects AI applications to external systems. MCP servers expose three core features: tools that models can call, resources that applications can add as context, and prompts that users can invoke as reusable workflows. In practice, MCP changes what the assistant can reach.

Review criteria differ because the failure modes differ. Weak Skill instructions can encode the wrong procedure, skip a required check, or tell the assistant to trust the wrong source. Weak MCP servers can leak data, perform the wrong write, return stale data, or fail during auth.

Use a Claude Skill for repeatable method

Choose a Skill when Claude already has the tools it needs, but keeps needing the same operating instructions.

A useful SKILL.md covers these details without making the user repeat them every session:

  • trigger conditions for the method;
  • files, APIs, or references that should be inspected first;
  • steps that are safe to run without another prompt;
  • output shape and completion criteria;
  • helper scripts that should be used instead of improvised shell commands;
  • checks that must pass before the final answer reaches the user.

For example, a release-readiness Skill might tell Claude to inspect the diff, run a focused test suite, check docs, verify screenshots, and return a short launch-risk report. It may include a script that extracts changed routes or validates markdown links. GitHub access can stay in a connector; procedure stays in the Skill.

Use Skills for review standards, editorial voice, content QA, release checklists, data-cleaning recipes, migration playbooks, or repeatable report formats. Instructions that keep getting pasted into chats probably belong in a Skill.

Use MCP for live access

Use MCP when the assistant needs a connection it does not already have: a database, SaaS workspace, remote API, local app, filesystem service, analytics provider, wallet, or agent endpoint.

An MCP server can expose a tool such as:

{
  "name": "search_leads",
  "description": "Search public influencer profiles by keyword, location, or follower range.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "country": { "type": "string" },
      "limit": { "type": "integer", "minimum": 1, "maximum": 100 }
    }
  }
}

A callable schema is only the first part. Server behavior still needs authentication, rate limits, logging, argument validation, and predictable error handling. Safe read-only calls should work before the user allows writes or paid actions.

Pick MCP when the assistant needs to fetch live data, call an operation, inspect a resource, or trigger a remote workflow. Skill instructions can describe how to use access; they cannot create the connection by themselves.

Use both for live access plus judgment

Live access plus judgment is where the two approaches fit together because neither side can finish the job alone. An MCP connector by itself is just a set of callable operations. A Skill without live access stops at advice. Combining them turns live facts into a repeatable decision path.

A customer-renewal workflow shows the split: MCP connectors can provide CRM notes, support tickets, usage events, and email history. Skill guidance can define the renewal brief: source order, privacy rules, required sections, risk scoring, and how to separate facts from inference.

Agent installation has the same shape. A directory can surface a public ERC-8004 agent with declared MCP, A2A, web, or x402 service entries. spawnr can install a supported MCP endpoint into local editor configs. Skill instructions can tell the assistant how to evaluate the agent before use: inspect identity, verify metadata resolution, run a demo call, check payment terms, and report what changed locally.

A concrete install review might use spawnr show base/30271, inspect the resolved services array, then run spawnr hire base/30271 --dry-run before touching editor config. When the MCP endpoint fails tools/list, the Skill should stop the install report there instead of treating the registration as usable.

This division keeps the workflow legible:

  1. MCP exposes the systems the assistant can reach.
  2. Skills define the method the assistant should follow.
  3. Directory scoring helps select a public agent worth inspecting.
  4. spawnr installs a supported service into the user's editor.

Directory role

The Spawn is not a replacement for Skills or MCP. It works as a trust surface for public ERC-8004 agents and agent-facing services.

At The Spawn, we shipped spawnr because install safety was the missing step between "found an agent" and "changed my editor config." Our rule is simple: discovery can suggest what to inspect, but installation should wait for a concrete chain ID, token ID, resolved service endpoint, and dry-run output.

Use The Spawn before installing an external capability:

  1. Search for agents by job, protocol, chain, or payment support.
  2. Open the agent page and inspect quality tier, score, services, and x402 hints.
  3. Check whether metadata is resolved, services are declared, and endpoints were observed live.
  4. Use /check when you have a chain and token ID but need a fresh read on metadata and endpoint shape.
  5. Use spawnr show <chain>/<id> and spawnr hire <chain>/<id> only after the service looks worth testing.

For background on the adjacent standards, read ERC-8004 vs MCP, MCP vs A2A, and the agent registration checklist.

Security review checklist

When reviewing a Skill, inspect SKILL.md, trigger text, bundled scripts, reference files, external fetches, and the permissions it asks the assistant to use. Shell scripts inside Skills deserve the same care as any small local automation.

For an MCP server, review publisher identity, transport, auth scopes, tool schemas, write actions, logs, rate limits, and what data leaves the client. Run one safe read-only call before allowing account changes, production writes, browser sessions, wallet actions, or payment.

For a Spawn-discovered agent, add four checks: onchain identity, metadata resolution, endpoint behavior, and payment state. Registration alone does not make the agent callable. Declaration alone does not verify MCP. Paid tools need visible price, network, asset, recipient, and retry path before use.

FAQ

Claude Skills and API calls

Skill packages can call an API when they include or reference a script that does so, or when the assistant already has another tool capable of making the call. Procedure still belongs in the Skill. MCP fits better when the API should become a reusable, permissioned capability for AI clients.

MCP servers and instructions

Server prompts and tool descriptions help, but those hints are scoped to that server. Skill guidance is more useful when the workflow crosses tools, files, teams, or review standards and needs one reusable method.

What agent builders should publish

Publish a Skill when the value is a repeatable method. Publish an MCP server when the value is a callable service or data source. Publish both when users need a tool and a disciplined way to use it.