Context Engineering Certification: Skills, MCP, and Prompts

If you are studying for a context engineering certification, the first thing to settle is what "context engineering" actually means in an exam context. It is not a single domain on either the CCAR-F or CCDV-F blueprints. Instead, it is a cross-cutting discipline that touches Prompt Engineering & Structured Output, Context Management & Reliability, and Tool Design all at once. Getting that framing right before you sit either exam is worth more than memorising any individual concept.

This post maps the three main levers of context engineering, namely Skills, MCP integration, and prompt structure, to the specific exam domains where they are tested, and shows you the practical patterns that scenario-based items reward.

What does "context engineering" mean for the CCAR-F exam?

Context engineering is the deliberate craft of deciding what information enters a model's context window, in what form, at what point in a workflow, and how much of it to retain or discard. On the CCAR-F blueprint, that craft is tested most heavily in Domain 5 (Context Management & Reliability, 15%) and Domain 4 (Prompt Engineering & Structured Output, 20%), but it bleeds into Domain 1 (Agentic Architecture & Orchestration, 27%) whenever a coordinator must pass structured state to subagents.

The CCDV-F blueprint distributes the same concerns differently: Domain 6 (Prompt and Context Engineering) carries 11.0% of the exam, while Domain 2 (Applications and Integration) carries the largest single weight at 33.1%. Candidates preparing for both tracks need to understand that the same underlying skill, say, deciding when to summarise versus when to pass full history, is tested at different levels of abstraction depending on the track.

How do Skills, MCP, and prompts differ as context levers?

These three mechanisms are complementary layers, not competing alternatives. Understanding where each one sits in the stack is the kind of conceptual clarity that scenario items test directly.

Skills are reusable instruction sets, typically stored as markdown files in a .claude/commands/ directory, that a user or agent invokes by name. A Skill does not execute code by itself; it loads a structured prompt into the context window. The description field in a Skill's YAML frontmatter is what Claude reads to decide whether to load the Skill automatically. If that description is vague, Claude will not route to it reliably, which is a common failure mode the exam tests.

MCP (Model Context Protocol) operates one layer below Skills. An MCP server exposes tools, resources, and prompts over a standardised protocol. When Claude Code connects to an MCP server, the tools appear in the tool list and the prompts become invocable via /mcp__servername__promptname. MCP gives Claude access to live data and side-effecting actions; Skills give Claude structured instructions. A Skill can reference MCP tools, but the Skill itself is not an MCP construct.

Prompt engineering is the foundational layer. It governs how instructions, examples, XML structure, and reasoning scaffolds are composed inside any individual context window, whether that window was populated by a Skill, an MCP resource, or a direct system prompt.

When should you use a Skill versus an MCP tool versus a direct prompt?

The decision rule the exam rewards is proportionality: reach for the lightest mechanism that reliably solves the problem.

1. Direct prompt or system prompt when the instruction is short, stable, and applies to every interaction in a session. Adding a formatting rule to the system prompt is cheaper and more reliable than wrapping it in a Skill.
2. Skill when you have a multi-step workflow that a human or agent will invoke repeatedly by name, and where the instructions are long enough that embedding them in every system prompt would waste tokens or create maintenance overhead.
3. MCP tool when the task requires live data retrieval, a side-effecting action (writing a file, calling an API), or a capability that must be available across multiple agents without being duplicated in each agent's prompt.
4. MCP resource when you need to expose a large, structured content catalogue (documentation, a schema library) that agents can pull on demand rather than having it occupy the context window permanently.

The Tool Design & MCP Integration domain tests this decision at the architecture level. A common scenario item presents a team that has embedded the same 400-token instruction block in six different agent system prompts and asks what the lowest-effort fix is. The answer is almost always to extract it into a Skill or an MCP resource, not to refine the wording.

How does prompt structure affect context reliability?

Prompt structure is not cosmetic. The order and format of information inside a context window affects which parts of it Claude attends to, and the exam tests that directly through the attention dilution problem.

The four structural levers, ranked by leverage for complex tasks:

1. Few-shot examples are the highest-leverage technique when the task involves ambiguous edge cases or extraction quality. A well-constructed example demonstrates the desired output format, the reasoning path, and the handling of edge cases simultaneously.
2. XML tags create explicit boundaries that help Claude distinguish between instruction, context, and data sections. For structured output tasks, wrapping input data in <document> tags and instructions in <instructions> tags reduces the risk of the model treating data as instruction.
3. Explicit step-by-step reasoning scaffolds (chain-of-thought) improve reliability on multi-step tasks but add tokens. The exam rewards knowing when the token cost is justified.
4. Explicit categorical criteria outperform vague qualitative descriptions. "Flag any claim that lacks a named source" is a better instruction than "check for unsupported claims."

<instructions>
  Summarise the document below. Include only claims that have a named source.
  Output format: JSON with fields "summary" (string) and "unsourced_claims" (array of strings).
</instructions>
<document>
  {{DOCUMENT_CONTENT}}
</document>

The XML structure above is the kind of pattern Domain 4 scenario items test. Note that the instruction and data are separated, the output format is explicit, and the edge case (unsourced claims) is handled by the schema rather than left to the model's judgement.

How does context management interact with agentic architecture?

In multi-agent systems, context engineering becomes a coordination problem. Each subagent has its own context window, and the coordinator must decide what to pass, in what form, and when. The structured context passing pattern addresses this directly: rather than forwarding raw conversation history, the coordinator serialises only the facts a subagent needs for its specific task.

The stale context problem is a related failure mode. In extended sessions, early facts in the context window can be contradicted by later ones, and the model may attend to the wrong version. The exam-preferred solution is to inject a summary block at the start of a fresh session rather than resuming a degraded context.

{
  "role": "user",
  "content": [
    {
      "type": "text",
      "text": "<session_summary>Customer: Acme Corp. Open issue: invoice #4421 disputed. Last action: refund approved by agent on 2026-06-15. Next step: confirm refund posted.</session_summary>\n\nThe customer is following up on their refund."
    }
  ]
}

This pattern, injecting a structured summary rather than replaying full history, is what the summary injection for fresh sessions concept covers in the CCAR-F concept library.

The CCAR-F exam draws four scenarios at random from a bank of six at each sitting, so any sitting may include a scenario that tests context handoff between agents. As of 12 March 2026, the exam has been live with 60 items across a 120-minute window, and Domain 1 carries the largest single weight at 27%.

What MCP patterns does the certification test?

The Tool Design & MCP Integration domain (18% of CCAR-F, 10.6% of CCDV-F) tests MCP at the design level, not the implementation level. The exam does not ask you to write an MCP server from scratch; it asks you to diagnose why an existing integration is failing and choose the proportionate fix.

The most frequently tested MCP patterns are:

The MCP isError flag pattern is one of the 174 atomic concepts in our CCAR-F concept library, mapped directly to the Domain 2 task statements.

How should you structure your exam preparation across these three layers?

Given the domain weights, a proportionate study allocation for CCAR-F looks like this:

The passing score is 720 on a 100-to-1000 scale. Anthropic does not publish the raw-to-scaled conversion, so we do not state an exact question count as the pass mark. What the score report does give you is percent-correct by domain, which means a failed attempt tells you exactly where to focus your remediation.

For CCDV-F candidates, Domain 2 (Applications and Integration, 33.1%) is the dominant weight and covers much of the same context engineering territory at the API integration level rather than the architecture level. Unlike CCAR-F, CCDV-F has no scenario bank; items are written directly against the skills in each domain.

Our adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, which means it will not move you past a concept until your demonstrated accuracy justifies it. For context engineering topics specifically, that matters because the concepts are interdependent: you cannot reliably answer a stale context scenario if you have not first mastered the summary injection pattern.

AI Skill Certs is an independent prep platform and is not affiliated with or endorsed by Anthropic. The CCAR-F and CCDV-F prep, including adaptive study, Archie tutoring, and practice exams, are live on the platform today.