GitHub MCP Tool Design: CCAR-F Architect Exam Guide

The GitHub MCP server connects Claude directly to your repositories, letting agents read code, open pull requests, and query issues without custom glue code. For candidates preparing for the CCAR-F exam, that convenience carries a corresponding responsibility: Domain 2 (Tool Design and MCP Integration, weighted at 18%) tests whether you understand what happens when real MCP servers meet real multi-agent systems, and GitHub MCP is a canonical example the exam scenario writers return to.

The CCAR-F exam covers five domains across 60 scenario-based items. Domain 2 is where the technical integration mechanics live. This guide covers the configuration mechanics, tool design principles, error patterns, and scoping decisions that Domain 2 scenario questions probe most frequently.

What does the GitHub MCP server expose?

The GitHub MCP server publishes tools covering common repository operations: reading file trees, fetching file contents, listing branches, creating or updating files, opening issues, and managing pull requests. Each tool is a discrete function with a JSON Schema describing its parameters. Claude sees those schemas the moment the server is registered and selects among them based on descriptions and the task at hand.

What the exam cares about is not the full tool catalogue but the design decisions that determine whether Claude routes correctly when multiple tools are present. The GitHub server, used without curation, surfaces a large tool set simultaneously. That creates the setup for the tool overload problem: too many tools with overlapping descriptions produce ambiguity, and Claude can invoke the wrong one. Recognising this pattern and choosing the right proportionate fix is the core skill Domain 2 tests.

How do you configure GitHub MCP in a Claude Code project?

The three-level configuration hierarchy places MCP server registrations in either user-level or project-level settings files. For GitHub MCP, a typical project-level entry in .claude/settings.json looks like this:

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

The ${GITHUB_TOKEN} syntax triggers environment variable expansion: the runtime substitutes the shell variable at startup rather than reading a literal string from the config file. This is the pattern the environment variable expansion in MCP config concept covers, and it matters for the exam because hard-coding credentials in a committed settings file is a security anti-pattern that scenario questions use as a distractor answer.

Project-level registration makes the server available to every Claude Code session opened in that directory. User-level registration in ~/.claude/settings.json makes it available globally. The MCP scoping hierarchy governs precedence when the same server name appears at both levels: project-level wins, letting teams enforce project-specific token scopes without requiring each contributor to update their global configuration.

What does Domain 2 test, mapped to GitHub MCP scenarios?

Domain 2 carries 18 per cent of the CCAR-F exam weight. Each sitting draws 4 scenarios from a bank of 6, and Domain 2 questions present a described system, a symptom, and four candidate fixes. The task statements map directly onto GitHub MCP integration challenges:

The exam consistently rewards the proportionate fix. For GitHub MCP scenarios, that is almost always a description change or a scope adjustment rather than a full architectural rebuild.

How do tool descriptions control GitHub MCP routing?

Claude selects tools by reading their descriptions. When two tools can plausibly serve a request, the one with the more specific, operation-focused description wins. Writing effective tool descriptions is the single highest-leverage change available when an MCP server behaves unexpectedly, and diagnosing tool misrouting is an explicit CCAR-F task statement.

Consider a coordinator managing a multi-agent code review pipeline. It has access to GitHub MCP and also to a custom post_internal_review tool. If GitHub MCP's create_issue description reads only "Creates a GitHub issue," Claude may invoke it for internal review comments that should never appear in the public repository. The fix is a single description change: "Creates a public GitHub issue visible to all repository contributors. Do not use for internal team comments or review notes."

The diagnostic loop the exam expects: identify the symptom, trace it to description ambiguity, apply the minimum change, verify no new surface area is introduced. Three of the four answer choices in a misrouting question will typically suggest architectural interventions. The correct answer narrows the description.

What error patterns does GitHub MCP introduce in agent pipelines?

The GitHub API returns structured errors across four conceptual categories: access failures (authentication and permission errors), resource errors (404 responses and missing branches), operational errors (rate limits and timeouts), and data errors (malformed input or schema violations). Each category warrants a different response strategy, and the exam tests whether you can identify the correct strategy from the symptom alone.

The MCP isError flag pattern is the mechanism Domain 2 probes most directly. When a tool call fails, the MCP server sets isError: true in the response alongside a human-readable message. A well-designed orchestrator checks that flag before deciding whether to retry, escalate, or continue with partial data.

def handle_tool_result(result):
    if result.get("isError"):
        error_code = result.get("errorCode", "UNKNOWN")
        raise ToolError(f"GitHub MCP error {error_code}: {result.get('message')}")
    return result.get("content")

A rate-limit response is recoverable: the orchestrator should apply exponential backoff and retry. A 404 on a repository lookup is non-recoverable for the current task: the orchestrator should surface it to the coordinator rather than retry silently. Conflating these two categories produces the silent suppression anti-pattern, which the exam penalises because downstream agents receive incomplete data without knowing it is incomplete.

In multi-agent pipelines, error propagation matters as much as the initial error response. If a subagent swallows a GitHub API error and returns an empty result, the coordinator loses the signal that data is missing. Structured error metadata requires subagents to return the error code and message alongside any partial results so the coordinator can route accordingly.

When should you build a custom tool instead of using GitHub MCP?

The build vs use decision for MCP servers is an explicit Domain 2 task statement. GitHub MCP is the right choice for general repository operations where the full tool surface is acceptable. A custom tool is warranted when:

1. The operation requires composing several GitHub API calls into an atomic step from the agent's perspective.
2. You need to constrain the agent to a single repository or branch, and description-level guardrails are insufficient.
3. The tool's output needs deterministic transformation before it is useful to the next pipeline stage.

Replacing generic with constrained tools frames this decision precisely: a narrow tool that performs exactly one operation beats a general tool that can do many when the agent's decision space must be tight. The exam may also present scenarios requiring scoped cross-role tools: when an agent needs write access for one task and read access for another, two scoped tools produce more predictable routing and a smaller security surface than one general-purpose tool.

How does the CCAR-F exam score GitHub MCP domain questions?

The score report returns a scaled score between 100 and 1,000, with 720 as the passing mark. Per-domain percent-correct breakdowns let you identify Domain 2 as a specific area of strength or weakness after each sitting. The raw-to-scaled conversion is not published by Anthropic, so we do not state a precise question count for passing; Domain 2's 18 per cent weight implies roughly 10 to 11 items in a 60-question paper.

The exam rewards candidates who reason from symptom to minimum-change fix. Scenarios presenting architectural overhauls as the correct answer are almost always distractors. The tell is proportionality: if a fix would take a team a week to implement when a one-line description change achieves the same outcome, the larger fix is wrong. Candidates who have built with GitHub MCP in day-to-day development have a practical foundation; the typical exam gap is not the tool knowledge but the ability to reason from symptom to root cause under time pressure across 120 minutes.

The tool design and MCP integration concepts library covers all Domain 2 task statements, with 174 atomic concepts mapped across the five CCAR-F domains. If GitHub MCP scenarios are a weak area after a practice sitting, MCP server integration best practices and tool choice application scenarios are the most targeted revision path.

The CCAR-F exam costs $125 per attempt and is delivered via online proctoring or at a Pearson VUE test centre. The credential is valid for 12 months from the award date. As of 3 June 2026, more than 10,000 individuals had earned a Claude certification across the programme's four tracks, underpinned by the $100M Claude Partner Network.