MCP Server Certification: Skills, Claude Code & Prompts

Candidates preparing for mcp server certification often hit the same conceptual wall: the docs describe skills, MCP servers, hooks, and commands as distinct mechanisms, yet in a real Claude Code workflow they all interact. Getting them confused on exam day costs marks in Domain 2 (Tool Design & MCP Integration) and Domain 3 (Claude Code Configuration & Workflows) on the CCAR-F, and in Domains 1, 6, and 8 on the CCDV-F. This guide maps each mechanism to its purpose, shows where the exam draws the lines, and explains how they compose in production.

What is the difference between a Claude Code skill and an MCP server?

A skill is a procedural knowledge document: a SKILL.md file with YAML frontmatter that tells Claude Code how to perform a workflow. An MCP server is a running process that exposes tools, resources, and prompts over the Model Context Protocol. Skills live in your repository or configuration directory and are loaded into context; MCP servers run externally and are called at inference time.

The distinction matters because the exam tests whether you reach for the right mechanism. Skills handle workflow guidance and procedural context. MCP servers handle external data access, API calls, and tool-connected agentic tasks. A skill cannot replace an MCP server when the task requires live data or a side-effecting action against an external system.

The exam consistently rewards answers that match the mechanism to the problem. Reaching for a skill when the scenario requires live API access, or spinning up an MCP server when a well-written SKILL.md would suffice, are both penalised.

How do Claude Code skills work technically?

A skill is a Markdown file with a YAML frontmatter block. The frontmatter declares a description field that Claude Code reads to decide whether to load the skill into the active context for a given task. This is dynamic loading, not a static system prompt that is always present.

---
description: "Use this skill when writing or reviewing database migration scripts"
allowed-tools:
  - Read
  - Edit
  - Bash
---

## Migration workflow

1. Read the existing schema with `Read`.
2. Draft the migration in a new file.
3. Validate with `Bash(npm run db:validate)`.
4. Write a rollback script before applying.

The description field is the selection mechanism. If it is vague or overlaps with another skill's description, Claude Code may load the wrong skill or none at all. This mirrors the tool descriptions as selection mechanism principle that applies equally to MCP tool definitions: the description is the routing logic.

Skills are not executable modules in the sense of compiled code. They are structured context documents. The "dynamic" quality comes from conditional loading based on the description match, not from runtime execution of the Markdown itself.

How do you invoke MCP prompts inside Claude Code?

MCP servers can expose three primitives: tools, resources, and prompts. Prompts are server-defined templates that appear in Claude Code's slash-command menu. Discovery works by typing / in the Claude Code interface; the menu lists all registered commands including those from connected MCP servers.

The invocation syntax follows a namespaced pattern:

/mcp__<servername>__<promptname> [arguments]

For example, if a server named github exposes a prompt called create_pr, you invoke it as:

/mcp__github__create_pr title="Fix null pointer" branch="fix/null-ptr"

Arguments are passed as key-value pairs after the prompt name. The server receives them and returns a rendered prompt or initiates a tool call sequence. This is distinct from calling an MCP tool directly, which happens automatically when Claude decides to use it during inference rather than through an explicit slash command.

For the exam, the key distinction is: MCP prompts are user-initiated via slash commands; MCP tools are model-initiated during the agentic loop. Confusing the two leads to wrong answers on scenario items about when a human triggers an action versus when the model does.

What belongs in a skill versus an MCP server?

The decision rule is straightforward: if the capability requires calling an external system, reading live data, or performing a side-effecting action, it belongs in an MCP server. If it is procedural knowledge that helps Claude Code reason about how to do something within an existing tool set, it belongs in a skill.

Consider a scenario where a team wants Claude Code to follow a specific code review checklist. The checklist itself is procedural knowledge with no external dependencies. A SKILL.md is the right home. Now consider a scenario where the review must fetch the current lint rules from a remote configuration service. That fetch requires an MCP tool.

The MCP server integration best practices concept covers this boundary in detail. The exam's Domain 2 (18% of CCAR-F) tests exactly this judgement: given a scenario, identify whether the right abstraction is a tool definition, a resource, a prompt, or a skill document.

How do skills, MCP, hooks, and commands compose in a team workflow?

In a well-structured team setup, the four mechanisms occupy distinct layers that compose without overlap:

1. Skills define how to perform recurring workflows (migration scripts, PR descriptions, incident runbooks).
2. MCP servers provide access to external systems (GitHub, databases, internal APIs).
3. Hooks enforce invariants at tool-call boundaries (normalise output, block forbidden paths, log audit trails).
4. Custom commands provide shortcuts for frequently triggered sequences.

This layered model is what the exam calls a "bundled workflow." The CCAR-F Domain 3 (Claude Code Configuration & Workflows, 20%) tests whether candidates can identify which layer is responsible for a given failure. If a team's deployment check is inconsistently applied, the fix is likely a hook or a command, not a new skill. If the check is applied but uses stale data, the fix is in the MCP layer.

The three-level configuration hierarchy governs where each of these artefacts is stored and which scope they apply to: user-level, project-level, or organisation-level. Misidentifying the scope is a common exam error.

How does prompt engineering fit into MCP server certification prep?

Prompt engineering is not separate from MCP work; it is embedded in it. Every MCP tool definition contains a description that is itself a prompt fragment. Every skill's description frontmatter field is a zero-shot classifier. Every custom command's body is a structured prompt.

The CCAR-F Domain 4 (Prompt Engineering & Structured Output, 20%) and CCDV-F Domain 6 (Prompt and Context Engineering, 11.0%) both test whether candidates can write prompts that produce reliable, structured output rather than vague natural-language responses.

For MCP tool descriptions specifically, the writing effective tool descriptions principle applies: be explicit about when to use the tool, what inputs it expects, and what it returns. Vague descriptions cause tool misrouting, which the exam treats as an architectural defect, not a model limitation.

A well-engineered tool description looks like this:

{
  "name": "get_open_incidents",
  "description": "Returns all open incidents from PagerDuty with severity P1 or P2. Use this tool when the user asks about current outages, active alerts, or on-call status. Do NOT use for historical incident data; use get_incident_history instead.",
  "input_schema": {
    "type": "object",
    "properties": {
      "team_id": {
        "type": "string",
        "description": "The PagerDuty team identifier. Required."
      }
    },
    "required": ["team_id"]
  }
}

The negative instruction ("Do NOT use for historical incident data") is a deliberate disambiguation. The exam rewards this pattern because it prevents the tool overload problem where a model selects the wrong tool from a large set.

How are MCP skills tested across CCAR-F and CCDV-F?

The two exams test overlapping but distinct slices of MCP knowledge. Understanding the split helps you allocate study time.

The CCAR-F (60 items, 120 minutes, passing score 720 on a 100-to-1000 scale, $125 per attempt) tests architectural judgement: given a broken multi-agent workflow, identify the root cause and the proportionate fix. The CCDV-F (53 items, 120 minutes, same scoring scale and passing bar, $125 per attempt) tests implementation knowledge: given a code snippet or API call, identify what is wrong or what should change.

Both exams are scenario-based. Neither rewards recall of syntax alone. The CCAR-F draws 4 scenarios at random from a bank of 6 at each sitting, so you will encounter MCP-related scenarios in most sittings given their weight across Domains 1 and 2.

What study path covers MCP server certification topics most efficiently?

We recommend working through the Tool Design & MCP Integration concept cluster before the Agentic Architecture & Orchestration cluster, because MCP tool design is a prerequisite for understanding how orchestrators delegate to subagents via tools. The prompt engineering cluster then reinforces both, since effective tool descriptions and skill frontmatter are applied prompt engineering.

A practical four-week sequence:

1. Week 1: MCP primitives (tools, resources, prompts), tool description design, isError flag pattern, error propagation.
2. Week 2: Claude Code configuration hierarchy, skill authoring, hook design, command structure.
3. Week 3: Agentic orchestration patterns, coordinator responsibilities, subagent context isolation.
4. Week 4: Full practice exams under timed conditions; review percent-correct by domain from your score report.

Our adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, so it will surface the MCP and tool-design concepts where your knowledge is weakest rather than cycling through topics you have already mastered. AI Skill Certs is an independent prep platform and is not affiliated with or endorsed by Anthropic.