Claude Prompt Engineering Certification: Skills, MCP & Prompts

If you are preparing for the CCAR-F exam, the claude prompt engineering certification domain is the one that trips up the most candidates who already know how to write prompts. Domain 4 (Prompt Engineering & Structured Output) carries 20% of the exam weight, and the questions rarely ask you to write a prompt from scratch. They ask you to choose between a plain prompt, a Skill, and an MCP integration, and to justify that choice under real production constraints. This guide gives you the clean decision rule, the exam-relevant mental models, and the code patterns you need to answer those scenario questions confidently.

What does Domain 4 actually test?

Domain 4 accounts for 20% of the 60-item CCAR-F exam, making it one of the two heaviest domains alongside Domain 3 (Claude Code Configuration & Workflows, also 20%). Per Anthropic's exam guide, every item is scenario-based and tests practical judgement, not recall. That means you will not be asked to define "few-shot prompting." You will be given a production scenario and asked which technique, or which composition of techniques, is the proportionate fix.

The five domains and their weights are worth keeping in your working memory throughout study:

Domain 4 overlaps heavily with Domains 1, 2, and 3. A scenario about a multi-step Claude Code workflow will test prompt structure and Skill design and MCP invocation simultaneously. That is intentional: the exam rewards architects who see these layers as composable, not competing.

What is a Skill, and how does it differ from a system prompt?

A Skill is an on-demand markdown instruction bundle, not a persistent system prompt and not an MCP server. When Claude Code loads a Skill, it injects the Skill's content into the context at the moment the Skill is invoked, then discards it when the task is done. The system prompt, by contrast, is always present for every turn in a session.

The practical distinction matters for the exam. A system prompt is the right layer for standing rules that apply to every interaction: tone, safety constraints, output format defaults. A Skill is the right layer for task-specific procedures that you want available on demand but do not want polluting every turn's context budget.

Think of it this way: if a junior engineer should follow a procedure every time they touch a particular class of file, that procedure belongs in a Skill. If the rule applies regardless of what the engineer is doing, it belongs in the system prompt.

Our Prompt Engineering & Structured Output concept library maps this distinction to the specific task statements examiners test against.

When is a plain prompt enough?

A plain prompt is sufficient when three conditions hold simultaneously:

1. The task is well-defined and unlikely to recur in a form that benefits from reuse.
2. The required behaviour can be expressed in a single turn without branching logic.
3. No external data source or tool call is needed to complete the task.

When any of those conditions breaks down, you are looking at either a Skill (for reusable procedure) or an MCP integration (for external data or capability). The exam will present scenarios where one condition is borderline; the correct answer is usually the least complex solution that satisfies all constraints, which is the exam's consistent preference for proportionate fixes.

What is the decision rule for Skills vs MCP vs plain prompts?

The cleanest way to hold this in your head for exam day is a three-question filter:

Question 1: Is the behaviour reusable across sessions or users? If no, a plain prompt is likely sufficient. If yes, proceed to Question 2.

Question 2: Does the behaviour require external data, a live API call, or a capability that Claude cannot produce from its weights alone? If yes, MCP is the right layer. If no, proceed to Question 3.

Question 3: Is the behaviour a procedure (how to do something) rather than delegated work (do this thing for me)? If it is a procedure, use a Skill. If it is delegated work with isolated context, use a subagent.

Plain prompt  -->  one-off, single-turn, no external data
Skill         -->  reusable procedure, on-demand, no live external data needed
MCP           -->  live external data, API calls, or capabilities beyond model weights
Subagent      -->  delegated work requiring context isolation

The exam will test the boundary between Skills and subagents repeatedly. The key: a Skill tells Claude how to do something; a subagent does something in an isolated context. They are not mutually exclusive. A subagent can load a Skill to govern how it executes its delegated task.

How does Claude Code invoke MCP prompts?

Claude Code uses the /mcp__servername__promptname slash-command format to invoke MCP prompts directly. This is worth knowing precisely because exam scenarios will describe a team that has built reusable MCP prompts and ask you to identify the correct invocation pattern or diagnose why a prompt is not being found.

# Invoke an MCP prompt named "summarise_pr" from a server named "github-tools"
/mcp__github-tools__summarise_pr

MCP prompts can be treated as reusable workflow templates: they are defined on the server, versioned with the server, and invoked on demand. This makes them a stronger choice than a Skill when the workflow depends on live data from that server, because the prompt and the data source are co-located.

The MCP Scoping Hierarchy concept covers how server-level, workspace-level, and user-level scoping affects which MCP prompts are available in a given Claude Code session.

What does exam-ready prompt structure look like for Claude Code tasks?

For Claude Code scenarios specifically, the exam rewards prompts that are explicit, structured, and example-driven. The reasoning is straightforward: Claude Code operates in an agentic loop where ambiguous instructions compound across tool calls. A vague prompt that works in a single-turn chat will produce unpredictable behaviour across a five-step agentic workflow.

The four structural elements the exam expects you to recognise:

1. Goal statement - what the final state should look like, not the steps to get there.
2. Constraints - what must not happen (files not to touch, APIs not to call, formats to avoid).
3. Output specification - the exact schema or format of the result.
4. Examples - at least one worked example for any output that has non-obvious edge cases.

## Goal
Produce a JSON summary of all failing tests in the current run.

## Constraints
- Do not modify any source files.
- Do not call external APIs.
- Limit output to tests with status "FAILED" or "ERROR".

## Output format
{
  "failing_tests": [
    { "name": string, "file": string, "error_message": string }
  ]
}

## Example
Input: pytest output with two failures in test_auth.py
Output: { "failing_tests": [{ "name": "test_login_invalid", "file": "test_auth.py", "error_message": "AssertionError: expected 401, got 200" }] }

This structure maps directly to the Goal-Based vs Step-Based Prompts concept, which is tested in both Domain 1 and Domain 4 scenarios.

How do few-shot examples interact with structured output requirements?

Few-shot examples are the highest-leverage technique for structured output reliability. When an output schema has ambiguous edge cases (nullable fields, mixed types, optional nesting), a worked example resolves the ambiguity faster and more reliably than additional prose instructions.

The exam tests this in two ways. First, it will present a scenario where structured output is inconsistent and ask you to diagnose the cause. The answer is almost always missing or insufficient examples, not a schema error. Second, it will ask you to choose between adding more schema constraints and adding a worked example. The proportionate fix is the example, because it costs less context and produces more reliable behaviour.

{
  "system": "You extract product data from HTML. Return valid JSON matching the schema below.",
  "schema": {
    "product_name": "string",
    "price_gbp": "number | null",
    "in_stock": "boolean"
  },
  "examples": [
    {
      "input": "<div class='product'>Widget <span class='price'>£12.99</span> <span class='stock'>In stock</span></div>",
      "output": { "product_name": "Widget", "price_gbp": 12.99, "in_stock": true }
    },
    {
      "input": "<div class='product'>Gadget <span class='stock'>Out of stock</span></div>",
      "output": { "product_name": "Gadget", "price_gbp": null, "in_stock": false }
    }
  ]
}

The second example is the critical one: it shows how to handle a missing price field. Without it, the model will sometimes omit the field, sometimes return an empty string, and sometimes return zero.

What is the portability rule for Skills across Claude Code, Claude.ai, and the API?

A Skill defined as a markdown file (conventionally SKILL.md or a file in the .claude/skills/ directory) is portable in principle but scoped in practice. Claude Code can load Skills from the local filesystem. Claude.ai Projects can load Skills as project knowledge. The Anthropic API does not have a native Skill loader; you inject the Skill content manually into the system prompt or user turn.

For the exam, the portability question usually appears as: "A team wants to share a coding-style Skill across their Claude Code sessions and their Claude.ai Project. What is the correct approach?" The answer is to maintain the Skill as a single markdown file in version control and load it appropriately in each surface, rather than maintaining two separate copies. The Version Control Implications concept covers the configuration hierarchy that governs this.

The scope distinction also matters for security. A Skill loaded from a local file inherits the trust level of the local environment. An MCP server, by contrast, is a network-accessible process with its own permission model. Before connecting an MCP server to Claude Code, you should verify its provenance, review its declared permissions, and confirm it runs in an appropriate sandbox. The exam will present scenarios where a team connects an unreviewed MCP server and ask you to identify the risk.

How do Skills and subagents compose in a multi-step workflow?

The exam's most complex Domain 4 scenarios involve a multi-step Claude Code workflow where a coordinator spawns subagents, each of which loads a Skill to govern its behaviour. This is not an exotic pattern; it is the standard architecture for any workflow where different steps require different expertise.

The coordinator's prompt is goal-based (what the final deliverable looks like). Each subagent's Skill is procedure-based (how to do its specific task). The subagents run in isolated contexts, so the code-review Skill does not bleed into the test-generation context. This is the Subagent Context Isolation pattern applied to prompt engineering.

For the exam, when you see a scenario involving multiple specialised steps, the correct architecture almost always involves this composition: coordinator goal prompt + per-subagent Skill + structured output at each handoff. A single monolithic prompt trying to do all three steps is the anti-pattern the exam is designed to catch.

How should you allocate study time across Domain 4?

With 20% of the exam weight and significant overlap with Domains 1 and 3, Domain 4 rewards breadth over depth. Our recommendation, based on the 30 task statements mapped in the concept library at /concepts:

The CCAR-F exam draws 4 scenarios at random from a bank of 6 at each sitting, so you cannot predict which exact scenarios will appear. Broad coverage of the decision rules above is more reliable than deep memorisation of any single pattern.

The passing score is 720 on a 100-to-1000 scale. Anthropic does not publish the raw-to-scaled conversion, so we will not speculate on an exact question count. What we can say is that Domain 4's 20% weight means roughly 12 of the 60 items will touch prompt engineering directly, with additional items in other domains where prompt structure is a contributing factor.