Model Context Protocol Certification: Skills vs MCP Guide

If you are preparing for a model context protocol certification and find yourself unsure whether a given problem calls for a Skill, an MCP server, or both, you are not alone. This is the sharpest conceptual boundary in the CCAR-F exam's Domain 2 (Tool Design & MCP Integration, 18% of the exam) and it trips up candidates who have used Claude Code in practice but never formalised the mental model. This guide draws the line precisely, shows you how the two layers interact, and maps everything to the exam task statements you will be tested on.

What is the difference between a Skill and an MCP server?

A Skill is a documented procedure: it tells Claude how to behave when performing a class of task. An MCP server is an integration layer: it gives Claude the capability to act on external systems. The distinction is behaviour guidance versus tool access.

In Claude Code, a Skill lives in a SKILL.md file (or a file referenced by frontmatter). It contains instructions, conventions, and examples that Claude loads into its working context when the skill is relevant. An MCP server, by contrast, exposes tools, resources, and prompts over the Model Context Protocol so that Claude can call external APIs, read databases, or run processes.

Put simply: if the problem is "Claude does not know our deployment procedure," a Skill is the right layer. If the problem is "Claude cannot reach our deployment API," an MCP server is the right layer. Many real workflows need both.

The exam consistently tests whether you can identify which layer solves a given symptom. A scenario where Claude repeatedly ignores your naming conventions points to a missing Skill. A scenario where Claude cannot retrieve live data points to a missing or misconfigured MCP server. See our Tool Design & MCP Integration concept library for the full taxonomy.

How do you create and structure a Claude Code Skill?

A Skill is a Markdown file with YAML frontmatter that tells Claude when and how to load it. The frontmatter declares a name, a description (used for auto-selection), and optionally a triggers list. The body is free-form Markdown: step-by-step procedures, decision rules, examples, and constraints.

---
name: deploy-to-staging
description: Use this skill when deploying any service to the staging environment.
triggers:
  - deploy
  - staging
  - release candidate
---

## Deployment procedure

1. Run `npm run build` and confirm zero TypeScript errors.
2. Tag the commit: `git tag rc-<version>`.
3. Call the `deploy_service` MCP tool with `env: staging`.
4. Monitor the `/deploy/status` MCP resource until `state` is `healthy`.

Notice that the Skill body references an MCP tool (deploy_service) and an MCP resource (/deploy/status). This is the canonical answer to the question "can a Skill call MCP tools?" Yes: a Skill orchestrates the procedure; MCP provides the execution capability. The two layers are complementary, not mutually exclusive.

Claude decides which Skill to load based on the description field acting as a semantic selector. When Claude Code sees a user request that matches the description, it auto-loads the skill into context. This is why writing precise, scenario-specific descriptions is a high-leverage activity, exactly the same principle that governs tool descriptions as a selection mechanism.

How do MCP prompts appear in Claude Code, and how do you run them?

MCP servers can expose three primitives: tools (callable functions), resources (readable content), and prompts (pre-built instruction templates). In Claude Code's CLI, MCP prompts surface in the / command menu. The invocation syntax is:

/mcp__<servername>__<promptname>

For example, if your MCP server is named github and it exposes a prompt called summarise_pr, you invoke it as:

/mcp__github__summarise_pr

This is a first-class workflow in Claude Code, not a workaround. MCP prompts are useful when you want a server-defined starting instruction that combines tool context with a structured task framing. From an exam perspective, know that MCP prompts are distinct from Skills: prompts are server-side templates invoked on demand; Skills are client-side procedure documents loaded into context.

The MCP scoping hierarchy determines which servers are available in a given session: user-level config applies globally, project-level config applies to a repository, and inline config applies to a single invocation. Exam scenarios often hinge on diagnosing why a tool is unavailable, and the answer is almost always a scoping mismatch.

When should you use a Skill vs an MCP server?

The decision rule is straightforward once you identify the root cause of the gap:

The CCAR-F exam rewards proportionate fixes. If a scenario describes Claude misrouting a tool call, the correct answer is almost never "rewrite the system prompt." It is more likely "improve the tool description" or "split the overloaded tool into two specific tools." See diagnosing tool misrouting for the full diagnostic framework.

A useful heuristic: if you can solve the problem by writing Markdown, it is a Skill problem. If you need a running process that Claude can call, it is an MCP problem.

What does the CCAR-F exam actually test about MCP integration?

Domain 2 (Tool Design & MCP Integration) carries 18% of the exam weight, which translates to roughly 10 to 11 items across a 60-question paper. The domain's task statements cluster around four themes:

1. Tool description quality: writing descriptions that route correctly, diagnosing misrouting, splitting overloaded tools.
2. Error handling: using the isError flag, structuring error metadata, distinguishing access failures from valid empty results.
3. Tool distribution strategy: deciding which tools belong to which agent, using tool_choice configuration, scoping cross-role tools.
4. MCP configuration: environment variable expansion, scoping hierarchy, build-vs-use decisions for MCP servers.

The exam does not test MCP protocol internals or transport-layer details. It tests judgment: given a scenario, what is the right design decision? This is consistent with the exam's general philosophy: every item is scenario-based and tests practical judgment, not recall.

Domain 3 (Claude Code Configuration & Workflows, 20%) overlaps here because Claude Code's three-level configuration hierarchy governs how MCP servers are scoped. Understanding the three-level configuration hierarchy is therefore relevant to both domains.

How do subagents fit alongside Skills and MCP?

Subagents add a third layer: isolated context windows that can each carry their own Skills and MCP tool access. A coordinator agent decomposes a task, spawns subagents for parallel or sequential subtasks, and synthesises results. Each subagent operates independently, which prevents context contamination and allows specialisation.

The practical implication for Skills and MCP: a subagent can be given a narrow Skill (e.g., "you are the database migration specialist") and a restricted MCP tool set (e.g., only the db_migrate tool). This is the subagent context isolation pattern, and it is tested in Domain 1 (Agentic Architecture & Orchestration, 27%), the highest-weighted domain on the exam.

{
  "subagent": "db-migration-specialist",
  "skill": "skills/db-migration.md",
  "mcp_tools": ["db_migrate", "db_rollback", "db_status"],
  "context": "Migrate the `users` table schema per the attached diff."
}

The coordinator does not need to know the migration procedure in detail. It delegates to the subagent, which loads the relevant Skill and calls the appropriate MCP tools. This separation of concerns is both good production architecture and the pattern the exam rewards.

What does "behaviour vs actions" mean in Claude Code?

This is the mental model that unifies everything above. In Claude Code:

• Behaviour is how Claude reasons, decides, and communicates. Skills shape behaviour by injecting procedural knowledge and conventions into context.
• Actions are what Claude does to the world: API calls, file writes, database queries. MCP servers enable actions by exposing callable tools.

A well-designed Claude Code workflow separates these concerns cleanly. The Skill says "when deploying, always confirm the target environment before proceeding." The MCP tool deploy_service actually performs the deployment. Claude's behaviour (confirm first) is governed by the Skill; Claude's capability (deploy) is governed by the MCP server.

This separation also makes systems easier to audit and maintain. Changing the deployment procedure means editing a Markdown file. Adding a new deployment target means updating the MCP server. Neither change requires touching the other layer.

For exam preparation, the tool interface design for multi-agent systems concept covers how this separation scales to coordinator-subagent architectures, where the stakes of a misrouted tool call are higher because errors propagate across agent boundaries.

How should you approach prompt engineering for Claude Code exam questions?

Domain 4 (Prompt Engineering & Structured Output) carries 20% of the exam weight, equal to Domain 3. For Claude Code specifically, the exam tests four prompt engineering principles:

1. Explicit instructions: state constraints, formats, and decision rules directly. Do not rely on Claude inferring them.
2. Context provision: give Claude the information it needs at the point it needs it, not buried in a long preamble.
3. Examples: few-shot examples are the highest-leverage technique for tasks with ambiguous edge cases.
4. Structure: use XML tags, numbered lists, or JSON schemas to delimit sections of a prompt, especially for multi-step tasks.

These principles apply equally to Skill bodies, MCP tool descriptions, and direct prompts. A Skill that uses numbered steps and concrete examples will outperform one that uses vague prose. A tool description that states exactly what the tool does and does not do will route correctly more often than one that is generic.

Our prompt engineering concept library covers all 30 task statements across the five domains, with worked examples for each. The writing effective tool descriptions concept is particularly relevant for candidates who want to see the principles applied to MCP specifically.

How do you prepare efficiently for the MCP and Skills domains?

The CCAR-F exam has 60 items, a 120-minute time limit, and a passing score of 720 on a 100-to-1000 scale. Each sitting draws 4 scenarios at random from a bank of 6, so you cannot predict which scenario set you will face. Broad coverage across all five domains is more reliable than deep specialisation in one.

For the MCP-relevant domains (Domain 2 at 18% and Domain 3 at 20%), the highest-return preparation activities are:

1. Work through scenario-based practice questions that require you to diagnose a symptom and select a proportionate fix.
2. Study the MCP server integration best practices concept, which maps directly to Domain 2 task statements.
3. Practise distinguishing isError: true (tool executed but returned an error) from a valid empty result (tool executed successfully and found nothing). This distinction appears in multiple exam scenarios.
4. Understand the environment variable expansion in MCP config pattern, which is a common source of configuration bugs in exam scenarios.

AI Skill Certs is an independent prep platform (not affiliated with or endorsed by Anthropic). Our adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, so it routes you to the concepts where your knowledge is weakest rather than having you re-study material you already know. Practice exams mirror the real format: 60 questions, scored 100 to 1000, with 720 as the passing bar.