Claude Code for Developers: Skills, MCP, and Prompts

The single most common question we hear from developers preparing for the CCDV-F exam is a deceptively simple one: "What belongs in a skill, what needs MCP, and what should just be a prompt?" Getting that mental model right is the core of claude code for developers in 2026, and it is also the lens through which Domain 2 (Applications and Integration, 33.1% of the exam) and Domain 8 (Tools and MCPs, 10.6%) are tested. This guide works through each layer in turn, maps the decision logic, and shows you what exam scenarios look like in practice.

What is the skills-MCP-prompt mental model?

The cleanest framing is: skills are behaviour, MCP is tools, and prompts are instructions. Each layer has a different scope, a different persistence mechanism, and a different cost of change.

• A skill is a reusable behaviour pack that Claude Code auto-loads for a project or user. It lives in a .claude/skills/ directory (or the equivalent bundled location), and it shapes how Claude approaches a class of task without requiring the user to re-explain it every session.
• An MCP server exposes external capabilities as callable tools: a GitHub MCP server gives Claude the ability to open pull requests; a database MCP server lets it run queries. MCP is the right layer when you need Claude to act on an external system.
• A prompt (system prompt, user turn, or CLAUDE.md instruction) is the lightest-weight layer. It is the right choice when the guidance is short, session-specific, or does not need to persist across projects.

The exam tests whether you can place a requirement in the correct layer. Misrouting is the most common failure mode, and it maps directly to the Tool Design & MCP Integration concepts in the CCAR-F concept library.

How do Claude Code skills actually work?

Skills are auto-loaded behaviour packs. When Claude Code starts a session in a project directory, it scans for skill files and loads them into its working context before the first user turn. This means the behaviour is available immediately, without any explicit invocation by the user.

A skill file typically contains:

• A natural-language description of the behaviour (what Claude should do differently when this skill is active)
• Optional few-shot examples that demonstrate the expected pattern
• Scope metadata (project-level vs. user-level)

The key distinction from a slash command is persistence and scope. A slash command is invoked explicitly by the user at a specific moment. A skill is ambient: it is always active for the sessions it covers. The key distinction from a plain CLAUDE.md instruction is structure and reusability: skills are discrete, named, and can be versioned and shared across a team.

Per Anthropic's Claude Code documentation, the three-level configuration hierarchy governs which settings apply at the user, project, and enterprise level. Skills sit within that hierarchy and inherit its scoping rules.

Where do skills live?

Project-level skills are the most important for team workflows. Because they live in the repository, they are reviewed in pull requests, rolled back with git revert, and automatically applied to every developer who clones the project. This is the right home for skills like "always run the test suite before proposing a refactor" or "format all SQL queries in our house style."

When should you use MCP instead of a skill?

Use MCP when Claude needs to call an external system. The rule is straightforward: if the capability requires a network call, a database query, an API authentication, or any side effect outside the local codebase, it belongs in an MCP server, not a skill.

Common MCP integrations for developer workflows:

A skill cannot make a network call. It can only shape Claude's reasoning and output. If a developer asks "why isn't Claude opening the PR automatically?", the answer is almost always that the GitHub MCP server is not configured, not that the skill is wrong.

The MCP scoping hierarchy determines which MCP servers are available in a given session. Like skills, MCP servers can be scoped to the user, the project, or the enterprise. Environment variable expansion in MCP config is the standard pattern for keeping credentials out of committed configuration files.

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

The ${GITHUB_TOKEN} expansion means the token is read from the shell environment at runtime, never stored in the repository. This is the pattern the exam expects you to recognise as correct.

When is a prompt the right answer?

A prompt is the right answer when the guidance is:

• Session-specific: "For this conversation, respond only in Spanish."
• Short and unlikely to recur: "Summarise this file in three bullet points."
• Exploratory: You are not yet sure whether the pattern is worth encoding as a skill.

The mistake to avoid is over-engineering. If a developer writes a 400-token system prompt that re-explains the team's coding conventions every session, the correct fix is to move those conventions into a project-level skill or a CLAUDE.md file, not to optimise the prompt further. The low-effort high-leverage fix principle applies here: the highest-leverage intervention is usually the one that removes the need to repeat yourself.

For prompt discipline specifically, the exam rewards being explicit, providing context, and using examples. Few-shot examples are the highest-leverage technique for getting reliable structured output from Claude Code. A prompt that shows Claude two examples of the expected output format will outperform a prompt that describes the format in prose, especially for extraction and transformation tasks.

How do you design reusable prompt templates for Claude Code?

A reusable prompt template for Claude Code has four components:

1. Role and context: Who is Claude acting as, and what does it know about the project?
2. Task specification: What exactly should Claude do? Use imperative language and be specific about scope.
3. Output format: What should the response look like? If structured output is required, provide a schema or a few-shot example.
4. Constraints: What should Claude avoid? Explicit negative constraints ("do not modify files outside the src/ directory") reduce the risk of unintended side effects.

You are a senior backend engineer reviewing Python code for our payments service.

Task: Review the following function for security vulnerabilities only. Do not 
suggest style improvements or refactors unless they directly affect security.

Output format: Return a JSON array. Each item should have:
  - "line": the line number (integer)
  - "severity": "critical" | "high" | "medium" | "low"
  - "description": a one-sentence explanation of the vulnerability
  - "fix": a one-sentence recommendation

If no vulnerabilities are found, return an empty array [].

Example output:
[
  {
    "line": 42,
    "severity": "high",
    "description": "User input is interpolated directly into a SQL query.",
    "fix": "Use parameterised queries via the db.execute() interface."
  }
]

This template is reusable because it is parameterised: swap the function under review and the template works for any code in the payments service. It is also exam-ready: it demonstrates explicit task scoping, structured output with a schema, a few-shot example, and a negative constraint.

For more on how prompt engineering intersects with structured output design, see our Prompt Engineering & Structured Output concept library.

How does this map to the CCDV-F exam?

The CCDV-F exam has 53 items across eight domains, with a passing score of 720 on a 100-to-1000 scale. The two domains most directly tested by the skills-MCP-prompt model are:

Together, these four domains account for 69.4% of the exam. A candidate who can correctly route a requirement to the right layer (skill vs. MCP vs. prompt) and explain why will be well-positioned across all four.

The exam is scenario-based: every item presents a realistic situation and asks you to choose the best action. A typical scenario might describe a team that wants Claude to automatically post a Slack message when a code review is complete, and ask whether the correct implementation uses a skill, an MCP server, a system prompt, or a webhook. The correct answer is an MCP server (Slack requires an authenticated API call), and the distractor answers test whether you confuse behaviour configuration with tool invocation.

What does a minimal but useful Claude Code stack look like?

For a solo developer or a small team starting out, we recommend a three-layer stack:

1. One project-level skill that encodes your team's most important repeatable behaviour (for example, "always write tests before implementation" or "always explain the reasoning before proposing a change").
2. Two or three MCP servers covering the external systems you touch most: typically GitHub, your primary database, and optionally a documentation or search tool.
3. A CLAUDE.md file at the project root with project-specific context: the tech stack, the directory structure, and any conventions that do not fit neatly into a skill.

Keep the stack minimal. The tool overload problem is real: giving Claude too many tools degrades its ability to select the right one. Start with the tools you will use in every session and add more only when you have a concrete need.

For teams scaling beyond a handful of developers, version control implications become important. Project-level skills and MCP configuration files should be committed to the repository and reviewed like any other code. User-level customisations should stay out of the repository to avoid conflicts between individual preferences and team standards.

How does this connect to the CCAR-F Architect exam?

If you are preparing for the CCAR-F Architect exam rather than CCDV-F, the same mental model applies but at a higher level of abstraction. Architects are tested on how to design systems that use Claude Code reliably at scale, not just how to configure it for a single project. Domain 3 of CCAR-F (Claude Code Configuration and Workflows, 20% of the exam) covers the configuration hierarchy, hook design, and workflow enforcement patterns that underpin everything described in this guide.

The Claude Code Configuration & Workflows concept library covers 174 atomic concepts mapped to the five CCAR-F domains and 30 task statements. If you are studying for CCAR-F, that library is the right starting point. If you are studying for CCDV-F, our adaptive practice exams (53 questions, scored 100 to 1000 with 720 as the passing bar) are available on the platform today.

AI Skill Certs is an independent prep platform; we are not affiliated with or endorsed by Anthropic.