Claude Certification Blog
MCP server development is 2.1% of the Claude developer exam
The subject that dominates every conversation about building with Claude is worth about one item on the developer exam, and the skill nobody talks about is worth two.
Tools and MCPs is 10.6% of CCDV-F — about 6 of 53 items — and it splits three ways: Tool Implementation at 4.4%, Agentic Customization at 4.1%, and MCP Server Development at 2.1%. That last figure is roughly one item, for the subject that takes up most of the oxygen whenever developers discuss building with Claude.
One domain, three uneven skills
| Skill | Weight | What it covers |
|---|---|---|
| Tool Implementation | 4.4% | Descriptions, boundaries, errors, and the set as a whole |
| Agentic Customization | 4.1% | Packaging a way of working so it is invoked, not retyped |
| MCP Server Development | 2.1% | Servers, primitives, and who controls which |
Attention against weight
CCDV-F is the only one of the four tracks publishing weights at skill level, which makes it the only exam where a gap like this can be measured instead of asserted. And the gap is large: a candidate who has spent a week reading about the Model Context Protocol has prepared thoroughly for roughly one question.
None of that makes the protocol unimportant, and it is examined more heavily elsewhere — 18% of CCAR-F sits in a domain named for tool design and MCP integration. What it means is track-specific: if you are sitting the developer exam, the reading list that circulates is weighted for a different paper. Our post on MCP across the four tracks sets out where it does carry weight.
Popularity is not a blueprint
The volume of writing about a topic reflects how new and interesting it is, not how many marks it carries. This domain is the clearest case in the programme, and it is worth checking your own revision against the published figures rather than against what felt worth reading.
Tool implementation, the largest
At 4.4% this is the biggest skill in the domain and the one with the most transferable judgment. Its subject is the contract: what a tool says it does, where it stops, what it returns when it fails, and how the set of them fits together.
The examinable failure is nearly always a boundary problem rather than a capability one. Two tools whose descriptions overlap produce selection errors that no amount of prompting fixes, because the description is how selection happens. Improving the prompt when the contract is ambiguous is the standard wrong answer, covered in tool use and structured output.
The skill nobody names
Agentic Customization is 4.1% — twice MCP — and it is the skill you will not find discussed anywhere near proportionally. Its subject is packaging a repeatable way of working so that it is invoked rather than reproduced: a procedure that would otherwise live as a paragraph each engineer keeps their own copy of.
The judgment being examined is when something has earned packaging. A one-off sequence has not. A procedure three people have each written their own version of has, and the tell is that the versions have started to drift. Packaging it converts a convention into something invoked the same way every time, which is the same guidance-versus-guarantee distinction that runs through Claude Code configuration.
What the 2.1% actually asks
One item, roughly, and it will not be about infrastructure. Running and hosting servers is explicitly excluded on the architect foundations guide — the only one of the four publishing an out-of-scope section — and nothing in the developer blueprint asks for it either.
What is examinable is narrower: authoring a server, the primitives it exposes, and which of those the model chooses to use against which the application decides to supply. That distinction is the one worth carrying into the exam, because it is the difference between a capability the model may reach for and material the application places in front of it.
How to spend six items
Two items’ worth of attention each on tool implementation and agentic customization, one on MCP. In practice that means most of the time goes on writing contracts — descriptions, boundaries, error shapes — and on recognising when a way of working should stop being retyped.
And if you are preparing across tracks, note that this allocation is specific to the developer exam. The architect foundations paper spends 18% on tool design and MCP integration together, which is a different study plan built from the same material — see the domain weights for all four tracks.
Key takeaways
- MCP server development is 2.1%. About one item on a 53-item paper, for the most discussed subject in the field.
- Agentic customization is worth twice that. At 4.1%, and almost nobody names it in a study plan.
- Tool implementation is the largest. Contracts, boundaries and error shapes at 4.4%.
- Boundaries beat prompting. Overlapping descriptions cause selection errors that no instruction fixes.
- Packaging has a trigger. Three drifting copies of one procedure, not a sequence used once.
- Check revision against weights. How much is written about a topic says nothing about what it scores.
Six items, and most people prepare for the smallest one
This is the clearest case in the programme of study time following interest rather than allocation, and a timed paper is the fastest way to notice you have done it. Papers built to the published 53-item split put all three skills in proportion. Our claude certification study guide covers how to sequence them.
See the CCDV-F blueprintQuestions
Frequently asked
The follow-up questions people search next.
How much of the Claude developer exam is MCP?
MCP Server Development is a published skill worth 2.1% of CCDV-F — roughly one item on a 53-item paper. The domain it sits in, Tools and MCPs, is 10.6% in total, so the other two skills in it account for most of the weight.
What is agentic customization?
The published skill covering packaging a repeatable way of working so it can be invoked rather than reproduced each time. At 4.1% it is worth nearly twice MCP server development, and it is the skill in this domain that almost nobody discusses.
What does tool implementation cover?
The largest skill in the domain at 4.4%: writing tool descriptions, defining where one tool stops and another starts, handling errors so a caller can recover, and constructing the tool set as a whole rather than one tool at a time.
Is deploying an MCP server examined?
No. Infrastructure for running servers sits on the out-of-scope list published by the architect foundations guide, and nothing in the developer blueprint asks for it. What is examined is authoring, the primitives a server exposes, and which of them the model controls against which the application controls.
How should I split time across this domain?
Roughly by weight: about two items each for tool implementation and agentic customization, and one for MCP. If your revision so far has been mostly MCP reading, you have spent it on the smallest of the three.
Keep reading
Related posts
Not affiliated with, or endorsed by, Anthropic or Pearson VUE. Details are summarised from publicly published program information and can change — always confirm against the official exam guide before booking.