MCP Certification: Skills vs MCP Servers for CCDV-F

The question of MCP certification competency on the CCDV-F exam is not simply "what is the Model Context Protocol?" It is a sharper, scenario-based question: given a specific runtime requirement, do you reach for an MCP server, a Claude Skill, a subagent, or some composition of all three? The Claude Certified Developer, Foundations exam (CCDV-F, $125, 53 items, 120-minute limit) tests exactly that judgement across its eight domains, with Tools and MCPs (Domain 8) weighted at 10.6% and Agents and Workflows (Domain 1) at 14.7%.

This guide works through the distinctions the exam actually tests, from the anatomy of a Skill to the conditions that force you to reach for a live MCP server instead.

What is a Claude Skill, and is it just a static prompt?

A Claude Skill is not a static prompt file. It is a versioned folder that bundles a prompt template, optional scripts, configuration metadata, and any supporting assets needed to execute a repeatable capability. Think of it as a self-contained unit of encoded behaviour: the folder contains a skill.md describing the skill's purpose and invocation contract, and it may contain helper scripts, few-shot examples, or structured output schemas.

The "prompts-as-code" philosophy treats each Skill folder as a first-class artefact in version control. A real-world example looks like this:

skills/
  summarise-pr/
    skill.md          # invocation contract, description, slash-command name
    prompt.txt        # the core prompt template with {{variables}}
    examples/
      example-01.json # few-shot input/output pair
      example-02.json
    scripts/
      fetch_diff.py   # optional pre-processing script

Committing this folder to git means every change to the prompt template, the few-shot examples, or the helper scripts is tracked, reviewable, and rollback-able. That is the "prompts-as-code" pattern in practice. The exam rewards candidates who understand that Skills are executable, versioned artefacts, not inert text blobs.

For a deeper look at how prompt templates and few-shot examples interact inside a Skill, our Prompt Engineering & Structured Output concept library covers the underlying mechanics.

How do you invoke a Skill in Claude Code?

Skills registered in Claude Code are invocable via a slash command whose name matches the skill.md declaration. If the skill folder is named summarise-pr and its skill.md declares command: /summarise-pr, then typing /summarise-pr in the Claude Code interface triggers that skill directly.

The invocation flow is:

1. Claude Code resolves the slash command against the registered skill registry.
2. It loads the skill.md contract and the associated prompt template.
3. Any declared variables are substituted from the current context (open file, selected text, session state).
4. Optional pre-processing scripts run before the prompt is submitted to the model.
5. The model response is returned, optionally post-processed by scripts in the skill folder.

This is meaningfully different from typing a free-form instruction. The slash command guarantees a deterministic prompt structure every time, which is why Skills are the right tool for repeatable, preference-encoded tasks (code style enforcement, PR summaries, commit message generation) rather than one-off queries.

When does a use case require an MCP server instead of a Skill?

This is the exam's sharpest distinction. Use an MCP server when the task requires live, external data or actions at runtime that cannot be embedded in a prompt template. Use a Skill when the task requires repeatable prompt behaviour that can be fully specified at authoring time.

A concrete exam scenario: an agent needs to fetch the current price of a stock symbol and format it as a structured report. The formatting preference (column order, currency symbol, decimal places) is a Skill. The live price retrieval is an MCP server tool call. Conflating the two is the error the exam is designed to catch.

Our Tool Design & MCP Integration concept library covers the MCP scoping hierarchy and error-handling patterns that appear in CCDV-F scenarios.

Which prompt-engineering techniques are most exam-critical for CCDV-F?

Domain 6 (Prompt and Context Engineering) carries 11.0% of the CCDV-F exam. The techniques the exam tests are not theoretical; they are applied in scenario items where you must diagnose why an output is wrong and select the highest-leverage fix.

Few-shot examples are consistently the highest-leverage technique when the model is producing outputs with inconsistent format or handling edge cases poorly. The exam rewards choosing few-shot over prompt rewriting when the root cause is example-absence rather than instruction-ambiguity.

For the mechanics of when and how to deploy few-shot patterns inside Skills, see our Tool Design & MCP Integration and Agentic Architecture & Orchestration concept pages, which cover how prompt patterns interact with tool calls and subagent delegation.

Can subagents access and reuse Skills the same way the main agent does?

This is a subtler exam question than it appears. Subagents in a multi-agent system operate with their own context window and their own tool access. Whether a subagent can invoke a Skill depends on how the orchestration layer is configured.

In Claude Code, Skills are registered at the session or workspace level. A subagent spawned within that session inherits the registered skill registry only if the orchestrator explicitly passes the skill context or if the subagent is launched within the same Claude Code workspace. A subagent running in an isolated context (for example, a fresh API call with no Claude Code session) does not automatically have access to the parent's skill registry.

The exam tests this through scenarios involving subagent context isolation: when a coordinator delegates a task to a subagent, the subagent's capabilities are bounded by what the coordinator explicitly provides. Skills are not magically inherited; they must be passed as part of the structured context passing pattern.

Practically, this means:

• If a subagent needs a Skill, the orchestrator must either invoke the Skill itself and pass the result, or configure the subagent's session to include the skill registry.
• MCP server access follows the same rule: tool availability is not ambient; it is explicitly scoped.

Are capability-uplift Skills more exam-relevant than encoded-preference Skills?

The CCDV-F exam tests both, but they appear in different domain contexts.

Encoded-preference Skills (React best practices, commit message style, PR summary format) are primarily tested in Domain 6 (Prompt and Context Engineering) and Domain 3 (Claude Code). The exam asks you to recognise when a preference should be encoded as a Skill rather than repeated in every system prompt.

Capability-uplift Skills (web scraping pipelines, data transformation, test generation) sit closer to the boundary with MCP servers and subagents. The exam is more likely to present a scenario where a capability-uplift Skill is the wrong answer because the task actually requires live data (MCP) or parallel execution (subagent). Recognising that boundary is the higher-order skill being tested.

The practical rule: if the "skill" requires network I/O or filesystem writes at runtime, it is not a Skill, it is an MCP server tool or a subagent task. If it requires only prompt-time reasoning with static context, it is a Skill.

Should developers default to Skills, subagents, or MCP in 2026?

The exam does not reward a single default. It rewards the ability to compose all three appropriately. The CCDV-F domain weights reflect this: Agents and Workflows (14.7%), Applications and Integration (33.1%), Tools and MCPs (10.6%), and Prompt and Context Engineering (11.0%) together account for nearly 70% of the exam. No single extensibility layer dominates.

The composition pattern the exam consistently rewards is:

Orchestrator (main agent)
  |-- Skill: /format-report        (encoded preference, deterministic)
  |-- MCP tool: fetch_live_data()  (runtime data, external system)
  |-- Subagent: analyse_corpus     (parallel, isolated context)

Each layer handles what it is best suited for. The exam penalises over-reliance on any single layer: using a Skill where live data is needed, using an MCP server where a simple prompt template would suffice, or spawning subagents for tasks that do not benefit from parallelism.

For the orchestration patterns that underpin this composition, our Agentic Architecture & Orchestration concept library covers hub-and-spoke architecture, parallel subagent spawning, and coordinator responsibilities in depth.

How does the CCDV-F exam weight these topics?

To orient your study time, here is the full domain breakdown for the CCDV-F exam per the official exam guide:

Domain 2 (Applications and Integration) is the single largest domain at 33.1%, which means the integration patterns between Skills, MCP servers, and the broader application stack are the highest-yield study area on the exam. Domain 8 (Tools and MCPs) at 10.6% is where the MCP-specific mechanics live, but the integration scenarios in Domain 2 will test MCP knowledge in applied context.

The CCDV-F exam has 53 items and a 120-minute time limit, scored on a 100 to 1000 scale with a passing score of 720. Unlike the CCAR-F Architect exam, CCDV-F does not draw from a scenario bank; items are written directly against the skills in each domain.

How does AI Skill Certs prepare you for these topics?

Our CCDV-F prep includes adaptive study sessions, practice exams mirroring the real 53-item format (scored 100 to 1000), and Archie, our Socratic tutor that guides you through scenario reasoning with graduated hints rather than giving answers directly. The adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, so it routes you toward the domains where your knowledge is weakest rather than drilling what you already know.

AI Skill Certs is an independent prep platform; we are not affiliated with or endorsed by Anthropic. Our CCDV-F practice exams and adaptive study are live today.