Agentic Customization: CCDV-F study guide

CCDV-F · Tools and MCPs, topic weight 4.1% of the exam

Agentic Customization is a topic in Domain 8, Tools and MCPs (10.6% of the CCDV-F exam), and carries 4.1% on its own, almost as much as Tool Implementation. It tests one decision: for a given use case, should you rely on a built-in tool, write a custom tool, write a Skill or build an MCP server?

What the official guide covers

The Claude Certified Developer Foundations exam guide (version 1.0, effective July 2026) describes this topic as the trade-offs among built-in tools, custom tools, Skills and MCPs, and choosing the right approach for a use case:

What the guide lists	What it means in practice
Built-in tools	Tools that ship with the platform: Claude Code's file, search, shell and web tools; API server tools such as web search and code execution; Anthropic-defined client tools such as bash and text editor
Custom tools	Functions you define with a schema and run in your own application, through the Messages API or the Agent SDK
Skills	Folders with a `SKILL.md` file of instructions, plus optional reference files and scripts, that Claude loads when relevant
MCPs	Separate servers that expose tools, resources and prompts over a standard protocol to any MCP client
Selecting the approach	Match the need (a capability, knowledge, reuse, ownership) and weigh context cost and control

What each option is

Built-in tools need no code. Claude Code already reads, edits and searches files, runs shell commands and fetches web pages. On the API, server tools run on Anthropic's infrastructure and return results directly. Built-in tools reach what the platform can reach: your files, your shell, the public web. They do not know your private systems.

Custom tools give Claude a function it cannot otherwise call. On the Messages API you send a tool definition and execute calls in your loop. In the Agent SDK you write the function with the @tool decorator (Python) or tool() (TypeScript), wrap it with create_sdk_mcp_server, and pass it in mcp_servers. That server runs inside your application, not as a separate process. A custom tool lives in one application.

Skills give Claude knowledge and workflows, not new connections. A Skill is a folder whose SKILL.md has YAML frontmatter (name, description) and instructions, with optional reference files and scripts. In Claude Code, Skills live in ~/.claude/skills/ (personal), .claude/skills/ (project) or a plugin, and you can run one directly with /skill-name. On the Claude API, Skills run with the code execution tool, with no network access and no package installs at run time.

MCP servers connect Claude to external systems through a standard protocol. One server can serve Claude Code, Claude Desktop, the Agent SDK and your own apps, and the server handles the connection and authentication.

What each costs in context

Option	What loads, and when
Custom tools on the Messages API	Every tool definition you send is part of each request, unless you defer it with tool search
Skills	Name and description at session start; the full body only when the Skill is used; bundled files only when read
MCP servers in Claude Code	Tool names at start; full schemas loaded on demand, because tool search is on by default
MCP servers through the API's MCP connector	Every enabled tool, unless `mcp_toolset` sets `enabled: false` or `defer_loading: true` for it
An enabled plugin	Names and descriptions of its Skills and agents on every turn, even when unused
Hooks (for contrast)	Nothing, unless the hook returns output

This is why Anthropic's Claude Code guidance says to move reference material out of CLAUDE.md, which loads in full every session, and into Skills, which load on demand.

One Skill, four runtimes

The same SKILL.md can run in several places, but each loads and sandboxes it differently:

Runtime	How the Skill loads	Where its steps run
Claude Code	Found in `.claude/skills/`, `~/.claude/skills/` or a plugin; loads on a description match or `/skill-name`	Your machine, under the session's permission mode and rules
Agent SDK	Found through the `user` and `project` setting sources, which default options load; if you set `setting_sources` yourself, include them or no Skills load. The `skills` option limits which ones Claude may invoke	Your process and your files
Claude API	Attached to the request and run with the code execution tool	Anthropic's container, with no network access and none of your local files
Claude Managed Agents (beta)	Listed on the agent definition you create once and reuse by ID	A sandbox Anthropic runs by default, not your machine

Three habits make a Skill portable. Write the description as the matching rule, because every runtime decides from it. Refer to bundled files through ${CLAUDE_SKILL_DIR} or ${CLAUDE_PROJECT_DIR}, never an absolute path from your own machine, and do not assume a local command exists. Remember that a subagent does not see the Skills you already invoked; list one in the subagent's skills field to preload it.

A useful test for when to write one: if you have typed the same multi-step instruction twice, it is a Skill. A verification Skill that runs the tests, reads the diff and reports the evidence is a good first one.

When the answer is a plugin

Skills, subagents, hooks and MCP servers all work on their own. A plugin packages several of them as one installable unit, distributed through a marketplace, so a team gets the same setup with one install and versioned updates. Three things to know:

Namespacing. Components are named under the plugin, so a review Skill in plugin my-plugin runs as /my-plugin:review and cannot clash with yours.
Paths. Scripts bundled with the plugin are referenced through ${CLAUDE_PLUGIN_ROOT}. A path to the author's home folder installs fine everywhere and fails everywhere but the author's machine. Test the install on a clean machine and document every environment variable the plugin needs.
Cost and trust. An enabled plugin is part of every session: its Skills' names and descriptions sit in context, its MCP servers run, and its hooks fire with your privileges. Organisations can allowlist marketplaces and force-install plugins through managed settings.

Knowledge or connection

Anthropic's comparison is short: MCP connects Claude to external services; Skills extend what Claude knows, including how to use those services well. They combine. An MCP server gives Claude access to your database; a Skill holds your schema notes and query patterns.

Skills and CLAUDE.md are instructions Claude interprets, so the outcome can vary. When something must happen every time, such as blocking an edit, use a hook. The Claude Code docs put it plainly: an instruction in CLAUDE.md or a Skill is a request, a PreToolUse hook is enforcement.

Worked example: a Skill on top of an MCP server

A finance team already has an MCP server for its warehouse. Claude can query it, but it does not know how the team builds the month-end report. A Skill fills the gap:

---
name: monthly-close-report
description: Builds the month-end close report from the finance warehouse. Use when someone asks for the close report, month-end numbers or variance against budget.
allowed-tools: Bash(python3 ${CLAUDE_SKILL_DIR}/scripts/variance.py *)
---

## Steps
1. Use the warehouse MCP tools to pull actuals for the month the user names.
2. Read budget-rules.md in this Skill's folder to map cost centres to budget lines.
3. Run `python3 ${CLAUDE_SKILL_DIR}/scripts/variance.py <month>` and include its table.
4. Flag any line more than 10% over budget and name the cost centre that owns it.

The description tells Claude when to load the Skill. allowed-tools pre-approves the one script it runs. Add disable-model-invocation: true to a Skill with side effects, such as a deploy, so it runs only when a person types its name.

Which option fits

Need	Choose	Why
Read, edit and test code in a repository	Built-in tools in Claude Code	Already there; nothing to build
Current results from the public web in an API app	A server tool such as web search	Anthropic runs it
Call one internal function from one application	A custom tool	Simplest; lives with the code that uses it
The same internal service from several Claude apps	An MCP server	Build once, connect many, maintain in one place
The team's way of doing a task, or reference docs used sometimes	A Skill	Loads only when relevant
Claude can reach a system but uses it badly	A Skill alongside the MCP server	Knowledge, not a new connection
Something must happen every time	A hook	Enforced, not interpreted
A working setup must reach the whole team	A plugin from a team marketplace	One install, versioned, namespaced
A Skill must also run in an API application	A Skill with no local paths or local commands	It runs in Anthropic's container

Rules that decide exam answers

Capability or knowledge? Tools and MCP servers let Claude do something new. Skills tell Claude how to do it well.
Reuse across applications points to MCP. One application and one function points to a custom tool.
Try built-in tools first. Do not build what Claude Code or a server tool already does.
Skills load on demand; CLAUDE.md is always on. Long reference material belongs in a Skill.
Instructions are not enforcement. Neither a Skill nor CLAUDE.md guarantees an outcome; a hook does.
Built-in tools stop at the platform's reach. Private APIs need a custom tool or an MCP server.

Where it appears in the exam

Tools and MCPs is Domain 8, 10.6% of the exam, and Agentic Customization is 4.1% of scored items, so expect about two questions in a 53-item exam. The guide's candidate profile names this trade-off directly: built-in, custom, Skills and MCPs. Expect a use case and four ways to extend Claude, where you pick the one that matches reuse, knowledge versus capability, and context cost.

Two sample questions

These are original Timo practice questions. They are not official exam questions.

Question 1

A team has an MCP server for its analytics database. Claude Code can query it but often joins deprecated tables and ignores the team's naming conventions. The team has 40 pages of guidance on the schema and query patterns. What is the best fix?

A. Build a second MCP server that wraps the first one with safer queries.B. Paste the 40 pages into the project's CLAUDE.md so Claude always has them.C. Copy the guidance into each MCP tool's description.D. Write a Skill holding the schema notes and query patterns, loaded when Claude works on analytics queries.

Answer: D. The gap is knowledge, and a Skill loads it only when needed. A adds a connection when the problem is know-how. B puts 40 pages into every session's context. C bloats every tool definition and still has to cover a whole schema.

Question 2

An Agent SDK application needs to convert amounts using the company's internal rates table. No other application uses it. A developer proposes a separate MCP server deployed on Kubernetes with OAuth. What fits best?

A. A Skill containing a copy of today's rates table as Markdown.B. A built-in web fetch call to a public exchange rate website.C. A custom tool defined in the application with the SDK's @tool decorator, reading the internal rates table.D. The proposed remote MCP server over Streamable HTTP with OAuth.

Answer: C. One application and one function call for a custom tool that runs in-process. A goes stale and gives no live access. B uses public rates, not the company's. D adds a service to deploy and secure with no reuse to justify it.

Build exercise

Pick one internal lookup, such as an order status. Implement it as a custom tool in an Agent SDK script with @tool and create_sdk_mcp_server.
Move the same function into a stdio MCP server and connect it to Claude Code with claude mcp add. Note what you had to change and what you gained.
Write a SKILL.md that explains how to use the tool well, with one example. Start a new session and confirm the Skill loads only when your request matches its description.
Write a half-page decision note for your team: which option you would ship for this lookup and why, using the table above.

Practise this topic

Claude Certified Developer practice exam: free, 20 questions, no sign-up
CCDV-F study guide: all topics
Previous topic: MCP Server Development

Sources

Claude Certified Developer Foundations Exam Guide, version 1.0, effective July 2026 (Anthropic), Domain 8 topic: Agentic Customization
Claude Code documentation: Extend Claude Code
Claude Code documentation: Extend Claude with Skills
Claude Platform documentation: Agent Skills
Claude Agent SDK documentation: Give Claude custom tools
Claude Code documentation: Plugins