Exam Prep
Anthropic · CCAR-F

Claude Certified Architect - Foundations

Validates the skills to design, build, and manage production applications with Claude — covers agentic architecture and orchestration, tool design and MCP integration, Claude Code configuration, prompt engineering and structured output, and context management and reliability.

Start Preparing

Free study references: Pages from Anthropic for every objective

Should I Take the CCAR-F?

You should work towards CCAR-F if you’re aiming for one of these careers:

  • AI solutions architect — designs end-to-end production systems built on Claude, including agentic workflows, tool integrations, and model choices.
  • Agentic AI engineer / AI agent engineer — builds and operates the multi-agent and tool-calling systems the exam's scenarios are drawn from, from customer-support agents to research pipelines.
  • Claude Code / developer productivity engineer — configures Claude Code for team workflows and wires it into CI/CD pipelines for code review, test generation, and pull-request feedback.
  • Forward-deployed or applied AI engineer — sits with a customer or business unit to turn a use case — document extraction, support automation, research synthesis — into a working Claude deployment.

CCAR-F is the entry point of Anthropic's certification stack. Anthropic has said that advanced architect, developer, and seller certifications sit above it, and that Foundations holders get priority access as those tiers launch — so the certification is also a step toward credentials Anthropic has not yet opened broadly.

Is the CCAR-F Worthwhile?

Here’s what we’d tell a friend:

  • It is Anthropic's own credential, not a third party's. This is Anthropic's first official technical certification, and it is proctored and scenario-based rather than a course-completion badge — the kind of validation a hiring manager or client can check against the vendor itself rather than a training company.
  • Pay for the roles it targets varies enormously by source and seniority. Figures seen in November 2026 for related titles span a wide range: ZipRecruiter put the US average for an AI agent engineer at $111,552 a year, or approximately $53.63 an hour, while a career-guide site reported ranges of $180-280K US for a senior AI agent engineer and Glassdoor listed an AI solutions architect average of $268,178 per year or $129 per hour, with top earners making up to $419,837. These differ because they measure different job titles, seniority levels, and company types — the certification alone will not set a salary; the role and experience behind it will. Source: Ai Agent Engineer Salary: Hourly Rate February 2026 USA, AI Agent Engineer: Job Description, Skills & Salary 2026, Ai Solutions Architect: Average Salary & Pay Trends 2026
  • This is a very young market. Anthropic only launched the certification on March 12, 2026, and has said that advanced architect, developer, and seller tiers are still arriving — so the credential's recognition among employers is still building, and few job postings yet name it specifically by code. Source: Claude Certified Architect, the complete guide to Anthropic's official certification in 2026
  • The exam tests judgment, not just recall. The scenarios cover real production patterns — multi-agent orchestration, MCP tool design, structured extraction, CI/CD integration — so preparing for it means building with the Agent SDK and Claude Code rather than memorizing facts, which carries over directly into the roles above.

How Long Will I Have to Spend Studying for the CCAR-F?

The honest answer is that it depends on how much you already know. Anthropic's own description of the candidate says the ideal candidate is a solution architect who designs and implements production applications with Claude, with hands-on experience across the Agent SDK, Claude Code, MCP tool design, prompt engineering for structured output, context management, and CI/CD integration, and typically 6+ months of practical experience building with Claude APIs, the Agent SDK, Claude Code, and MCP. If that’s your background, you’ve got a good start.

In our plan, you pick the areas of CCAR-F that matter to you — for the exam and for your job — and build a study plan from our domain reviews. Then you take an initial exam, backed by Anthropic’s own documentation, to see where you need to focus to meet your study plan’s goals (our exam review will show you that).

In our store, you can buy a single exam or, if you intend to stick with us, our standard package — which includes, for example, custom drills for the areas our review showed that you need to strengthen (both domain knowledge and exam-taking skills). Repeat with fresh exams, step up to a challenge exam, take advantage of Mentor, and walk into the real exam with your own two-page cheat sheet. See how it works.

How Hard Is the CCAR-F Exam?

Another honest answer: since Anthropic doesn’t publish pass rates, no one knows (including us). What Anthropic does publish: you need a scaled score of 720 or greater to pass, on a scale of 100 to 1,000 — not 72% of the questions. The skills it measures, and how much each area weighs, are listed below.

We can tell you that we update our exams monthly, so they always reflect the current state of both the certification and the documentation that supports it. That means our exams follow the certification’s current topic weights, and our domain reviews and explanations are always up to date.

Start Preparing

We can’t tell you how well you know the content — you need to take one of our real exams for that. But our full exams also tell you how you miss: what question answering habits are tripping you up (and we do it across six kinds of ‘bad habits’). We have over 100 answers written that not only test your knowledge but catch those specific bad habits.

These 10 questions, for example, find which kind of ‘almost right’ answers catch you:

Sample exam coming soon.

Skills at a glance

Agentic Architecture & Orchestration27%
  • Implementing agentic loop control flow that continues when stop_reason is "tool_use" and terminates when stop_reason is "end_turn"
  • Adding tool results to conversation context between iterations so the model can incorporate new information into its reasoning
  • Avoiding anti-patterns such as parsing natural language signals to determine loop termination, setting arbitrary iteration caps as the primary stopping mechanism, or checking for assistant text content as a completion indicator
  • Designing coordinator agents that analyze query requirements and dynamically select which subagents to invoke rather than always routing through the full pipeline
  • Partitioning research scope across subagents to minimize duplication (e.g., assigning distinct subtopics or source types to each agent)
  • Implementing iterative refinement loops where the coordinator evaluates synthesis output for gaps, re-delegates to search and analysis subagents with targeted queries, and re-invokes synthesis until coverage is sufficient
  • Routing all subagent communication through the coordinator for observability, consistent error handling, and controlled information flow
  • Including complete findings from prior agents directly in the subagent's prompt (e.g., passing web search results and document analysis outputs to the synthesis subagent)
  • Using structured data formats to separate content from metadata (source URLs, document names, page numbers) when passing context between agents to preserve attribution
  • Spawning parallel subagents by emitting multiple Task tool calls in a single coordinator response rather than across separate turns
  • Designing coordinator prompts that specify research goals and quality criteria rather than step-by-step procedural instructions, to enable subagent adaptability
  • Implementing programmatic prerequisites that block downstream tool calls until prerequisite steps have completed (e.g., blocking process_refund until get_customer has returned a verified customer ID)
  • Decomposing multi-concern customer requests into distinct items, then investigating each in parallel using shared context before synthesizing a unified resolution
  • Compiling structured handoff summaries (customer ID, root cause, refund amount, recommended action) when escalating to human agents who lack access to the conversation transcript
  • Implementing PostToolUse hooks to normalize heterogeneous data formats (Unix timestamps, ISO 8601, numeric status codes) from different MCP tools before the agent processes them
  • Implementing tool call interception hooks that block policy-violating actions (e.g., refunds exceeding $500) and redirect to alternative workflows (e.g., human escalation)
  • Choosing hooks over prompt-based enforcement when business rules require guaranteed compliance
  • Selecting task decomposition patterns appropriate to the workflow: prompt chaining for predictable multi-aspect reviews, dynamic decomposition for open-ended investigation tasks
  • Splitting large code reviews into per-file local analysis passes plus a separate cross-file integration pass to avoid attention dilution
  • Decomposing open-ended tasks (e.g., "add comprehensive tests to a legacy codebase") by first mapping structure, identifying high-impact areas, then creating a prioritized plan that adapts as dependencies are discovered
  • Using --resume with session names to continue named investigation sessions across work sessions
  • Using fork_session to create parallel exploration branches (e.g., comparing two testing strategies or refactoring approaches from a shared codebase analysis)
  • Choosing between session resumption (when prior context is mostly valid) and starting fresh with injected summaries (when prior tool results are stale)
  • Informing a resumed session about specific file changes for targeted re-analysis rather than requiring full re-exploration
Tool Design & MCP Integration18%
  • Writing tool descriptions that clearly differentiate each tool's purpose, expected inputs, outputs, and when to use it versus similar alternatives
  • Renaming tools and updating descriptions to eliminate functional overlap (e.g., renaming analyze_content to extract_web_results with a web-specific description)
  • Splitting generic tools into purpose-specific tools with defined input/output contracts (e.g., splitting a generic analyze_document into extract_data_points, summarize_content, and verify_claim_against_source)
  • Reviewing system prompts for keyword-sensitive instructions that might override well-written tool descriptions
  • Returning structured error metadata including errorCategory (transient/validation/permission), isRetryable boolean, and human-readable descriptions
  • Including retriable: false flags and customer-friendly explanations for business rule violations so the agent can communicate appropriately
  • Implementing local error recovery within subagents for transient failures, propagating to the coordinator only errors that cannot be resolved locally along with partial results and what was attempted
  • Distinguishing between access failures (needing retry decisions) and valid empty results (representing successful queries with no matches)
  • Restricting each subagent's tool set to those relevant to its role, preventing cross-specialization misuse
  • Replacing generic tools with constrained alternatives (e.g., replacing fetch_url with load_document that validates document URLs)
  • Providing scoped cross-role tools for high-frequency needs (e.g., a verify_fact tool for the synthesis agent) while routing complex cases through the coordinator
  • Using tool_choice forced selection to ensure a specific tool is called first (e.g., forcing extract_metadata before enrichment tools), then processing subsequent steps in follow-up turns
  • Setting tool_choice: "any" to guarantee the model calls a tool rather than returning conversational text
  • Configuring shared MCP servers in project-scoped .mcp.json with environment variable expansion for authentication tokens
  • Configuring personal/experimental MCP servers in user-scoped ~/.claude.json
  • Enhancing MCP tool descriptions to explain capabilities and outputs in detail, preventing the agent from preferring built-in tools (like Grep) over more capable MCP tools
  • Choosing existing community MCP servers over custom implementations for standard integrations (e.g., Jira), reserving custom servers for team-specific workflows
  • Exposing content catalogs as MCP resources to give agents visibility into available data without requiring exploratory tool calls
  • Selecting Grep for searching code content across a codebase (e.g., finding all callers of a function, locating error messages)
  • Selecting Glob for finding files matching naming patterns (e.g., **/*.test.tsx)
  • Using Read to load full file contents followed by Write when Edit cannot find unique anchor text
  • Building codebase understanding incrementally: starting with Grep to find entry points, then using Read to follow imports and trace flows, rather than reading all files upfront
  • Tracing function usage across wrapper modules by first identifying all exported names, then searching for each name across the codebase
Claude Code Configuration & Workflows20%
  • Diagnosing configuration hierarchy issues (e.g., a new team member not receiving instructions because they're in user-level rather than project-level configuration)
  • Using @import to selectively include relevant standards files in each package's CLAUDE.md based on maintainer domain knowledge
  • Splitting large CLAUDE.md files into focused topic-specific files in .claude/rules/ (e.g., testing.md, api-conventions.md, deployment.md)
  • Using the /memory command to verify which memory files are loaded and diagnose inconsistent behavior across sessions
  • Creating project-scoped slash commands in .claude/commands/ for team-wide availability via version control
  • Using context: fork to isolate skills that produce verbose output (e.g., codebase analysis) or exploratory context (e.g., brainstorming alternatives) from the main session
  • Configuring allowed-tools in skill frontmatter to restrict tool access during skill execution (e.g., limiting to file write operations to prevent destructive actions)
  • Using argument-hint frontmatter to prompt developers for required parameters when they invoke the skill without arguments
  • Choosing between skills (on-demand invocation for task-specific workflows) and CLAUDE.md (always-loaded universal standards)
  • Creating .claude/rules/ files with YAML frontmatter path scoping (e.g., paths: ["terraform/**/*"]) so rules load only when editing matching files
  • Using glob patterns in path-specific rules to apply conventions to files by type regardless of directory location (e.g., **/*.test.tsx for all test files)
  • Choosing path-specific rules over subdirectory CLAUDE.md files when conventions must apply to files spread across the codebase
  • Selecting plan mode for tasks with architectural implications (e.g., microservice restructuring, library migrations affecting 45+ files, choosing between integration approaches with different infrastructure requirements)
  • Selecting direct execution for well-understood changes with clear scope (e.g., a single-file bug fix with a clear stack trace, adding a date validation conditional)
  • Using the Explore subagent for verbose discovery phases to prevent context window exhaustion during multi-phase tasks
  • Combining plan mode for investigation with direct execution for implementation (e.g., planning a library migration, then executing the planned approach)
  • Providing 2-3 concrete input/output examples to clarify transformation requirements when natural language descriptions produce inconsistent results
  • Writing test suites covering expected behavior, edge cases, and performance requirements before implementation, then iterating by sharing test failures
  • Using the interview pattern to surface design considerations (e.g., cache invalidation strategies, failure modes) before implementing solutions in unfamiliar domains
  • Providing specific test cases with example input and expected output to fix edge case handling (e.g., null values in migration scripts)
  • Addressing multiple interacting issues in a single detailed message when fixes interact, versus sequential iteration for independent issues
  • Running Claude Code in CI with the -p flag to prevent interactive input hangs
  • Using --output-format json with --json-schema to produce machine-parseable structured findings for automated posting as inline PR comments
  • Including prior review findings in context when re-running reviews after new commits, instructing Claude to report only new or still-unaddressed issues to avoid duplicate comments
  • Providing existing test files in context so test generation avoids suggesting duplicate scenarios already covered by the test suite
  • Documenting testing standards, valuable test criteria, and available fixtures in CLAUDE.md to improve test generation quality and reduce low-value test output
Prompt Engineering & Structured Output20%
  • Writing specific review criteria that define which issues to report (bugs, security) versus skip (minor style, local patterns) rather than relying on confidence-based filtering
  • Temporarily disabling high false-positive categories to restore developer trust while improving prompts for those categories
  • Defining explicit severity criteria with concrete code examples for each severity level to achieve consistent classification
  • Creating 2-4 targeted few-shot examples for ambiguous scenarios that show reasoning for why one action was chosen over plausible alternatives
  • Including few-shot examples that demonstrate specific desired output format (location, issue, severity, suggested fix) to achieve consistency
  • Providing few-shot examples distinguishing acceptable code patterns from genuine issues to reduce false positives while enabling generalization
  • Using few-shot examples to demonstrate correct handling of varied document structures (inline citations vs bibliographies, methodology sections vs embedded details)
  • Adding few-shot examples showing correct extraction from documents with varied formats to address empty/null extraction of required fields
  • Defining extraction tools with JSON schemas as input parameters and extracting structured data from the tool_use response
  • Setting tool_choice: "any" to guarantee structured output when multiple extraction schemas exist and the document type is unknown
  • Forcing a specific tool with tool_choice: {"type": "tool", "name": "extract_metadata"} to ensure a particular extraction runs before enrichment steps
  • Designing schema fields as optional (nullable) when source documents may not contain the information, preventing the model from fabricating values to satisfy required fields
  • Adding enum values like "unclear" for ambiguous cases and "other" + detail fields for extensible categorization
  • Including format normalization rules in prompts alongside strict output schemas to handle inconsistent source formatting
  • Implementing follow-up requests that include the original document, the failed extraction, and specific validation errors for model self-correction
  • Identifying when retries will be ineffective (e.g., information exists only in an external document not provided) versus when they will succeed (format mismatches, structural output errors)
  • Adding detected_pattern fields to structured findings to enable analysis of false positive patterns when developers dismiss findings
  • Designing self-correction validation flows: extracting "calculated_total" alongside "stated_total" to flag discrepancies, adding "conflict_detected" booleans for inconsistent source data
  • Matching API approach to workflow latency requirements: synchronous API for blocking pre-merge checks, batch API for overnight/weekly analysis
  • Calculating batch submission frequency based on SLA constraints (e.g., 4-hour windows to guarantee 30-hour SLA with 24-hour batch processing)
  • Handling batch failures: resubmitting only failed documents (identified by custom_id) with appropriate modifications (e.g., chunking documents that exceeded context limits)
  • Using prompt refinement on a sample set before batch-processing large volumes to maximize first-pass success rates and reduce iterative resubmission costs
  • Using a second independent Claude instance to review generated code without the generator's reasoning context
  • Splitting large multi-file reviews into focused per-file passes for local issues plus separate integration passes for cross-file data flow analysis
  • Running verification passes where the model self-reports confidence alongside each finding to enable calibrated review routing
Context Management & Reliability15%
  • Extracting transactional facts (amounts, dates, order numbers, statuses) into a persistent "case facts" block included in each prompt, outside summarized history
  • Extracting and persisting structured issue data (order IDs, amounts, statuses) into a separate context layer for multi-issue sessions
  • Trimming verbose tool outputs to only relevant fields before they accumulate in context (e.g., keeping only return-relevant fields from order lookups)
  • Placing key findings summaries at the beginning of aggregated inputs and organizing detailed results with explicit section headers to mitigate position effects
  • Requiring subagents to include metadata (dates, source locations, methodological context) in structured outputs to support accurate downstream synthesis
  • Modifying upstream agents to return structured data (key facts, citations, relevance scores) instead of verbose content and reasoning chains when downstream agents have limited context budgets
  • Adding explicit escalation criteria with few-shot examples to the system prompt demonstrating when to escalate versus resolve autonomously
  • Honoring explicit customer requests for human agents immediately without first attempting investigation
  • Acknowledging frustration while offering resolution when the issue is within the agent's capability, escalating only if the customer reiterates their preference
  • Escalating when policy is ambiguous or silent on the customer's specific request (e.g., competitor price matching when policy only addresses own-site adjustments)
  • Instructing the agent to ask for additional identifiers when tool results return multiple matches, rather than selecting based on heuristics
  • Returning structured error context including failure type, what was attempted, partial results, and potential alternatives to enable coordinator recovery
  • Distinguishing access failures from valid empty results in error reporting so the coordinator can make appropriate decisions
  • Having subagents implement local recovery for transient failures and only propagate errors they cannot resolve, including what was attempted and partial results
  • Structuring synthesis output with coverage annotations indicating which findings are well-supported versus which topic areas have gaps due to unavailable sources
  • Spawning subagents to investigate specific questions (e.g., "find all test files," "trace refund flow dependencies") while the main agent preserves high-level coordination
  • Having agents maintain scratchpad files recording key findings, referencing them for subsequent questions to counteract context degradation
  • Summarizing key findings from one exploration phase before spawning sub-agents for the next phase, injecting summaries into initial context
  • Designing crash recovery using structured agent state exports (manifests) that the coordinator loads on resume and injects into agent prompts
  • Using /compact to reduce context usage during extended exploration sessions when context fills with verbose discovery output
  • Implementing stratified random sampling of high-confidence extractions for ongoing error rate measurement and novel pattern detection
  • Analyzing accuracy by document type and field to verify consistent performance across all segments before reducing human review
  • Having models output field-level confidence scores, then calibrating review thresholds using labeled validation sets
  • Routing extractions with low model confidence or ambiguous/contradictory source documents to human review, prioritizing limited reviewer capacity
  • Requiring subagents to output structured claim-source mappings (source URLs, document names, relevant excerpts) that downstream agents preserve through synthesis
  • Structuring reports with explicit sections distinguishing well-established findings from contested ones, preserving original source characterizations and methodological context
  • Completing document analysis with conflicting values included and explicitly annotated, letting the coordinator decide how to reconcile before passing to synthesis
  • Requiring subagents to include publication or data collection dates in structured outputs to enable correct temporal interpretation
  • Rendering different content types appropriately in synthesis outputs—financial data as tables, news as prose, technical findings as structured lists—rather than converting everything to a uniform format

Domains

Agentic Architecture & Orchestration27%
Design and implement agentic loops for autonomous task execution
  • Implementing agentic loop control flow that continues when stop_reason is "tool_use" and terminates when stop_reason is "end_turn"
  • Adding tool results to conversation context between iterations so the model can incorporate new information into its reasoning
  • Avoiding anti-patterns such as parsing natural language signals to determine loop termination, setting arbitrary iteration caps as the primary stopping mechanism, or checking for assistant text content as a completion indicator
Orchestrate multi-agent systems with coordinator-subagent patterns
  • Designing coordinator agents that analyze query requirements and dynamically select which subagents to invoke rather than always routing through the full pipeline
  • Partitioning research scope across subagents to minimize duplication (e.g., assigning distinct subtopics or source types to each agent)
  • Implementing iterative refinement loops where the coordinator evaluates synthesis output for gaps, re-delegates to search and analysis subagents with targeted queries, and re-invokes synthesis until coverage is sufficient
  • Routing all subagent communication through the coordinator for observability, consistent error handling, and controlled information flow
Configure subagent invocation, context passing, and spawning
  • Including complete findings from prior agents directly in the subagent's prompt (e.g., passing web search results and document analysis outputs to the synthesis subagent)
  • Using structured data formats to separate content from metadata (source URLs, document names, page numbers) when passing context between agents to preserve attribution
  • Spawning parallel subagents by emitting multiple Task tool calls in a single coordinator response rather than across separate turns
  • Designing coordinator prompts that specify research goals and quality criteria rather than step-by-step procedural instructions, to enable subagent adaptability
Implement multi-step workflows with enforcement and handoff patterns
  • Implementing programmatic prerequisites that block downstream tool calls until prerequisite steps have completed (e.g., blocking process_refund until get_customer has returned a verified customer ID)
  • Decomposing multi-concern customer requests into distinct items, then investigating each in parallel using shared context before synthesizing a unified resolution
  • Compiling structured handoff summaries (customer ID, root cause, refund amount, recommended action) when escalating to human agents who lack access to the conversation transcript
Apply Agent SDK hooks for tool call interception and data normalization
  • Implementing PostToolUse hooks to normalize heterogeneous data formats (Unix timestamps, ISO 8601, numeric status codes) from different MCP tools before the agent processes them
  • Implementing tool call interception hooks that block policy-violating actions (e.g., refunds exceeding $500) and redirect to alternative workflows (e.g., human escalation)
  • Choosing hooks over prompt-based enforcement when business rules require guaranteed compliance
Design task decomposition strategies for complex workflows
  • Selecting task decomposition patterns appropriate to the workflow: prompt chaining for predictable multi-aspect reviews, dynamic decomposition for open-ended investigation tasks
  • Splitting large code reviews into per-file local analysis passes plus a separate cross-file integration pass to avoid attention dilution
  • Decomposing open-ended tasks (e.g., "add comprehensive tests to a legacy codebase") by first mapping structure, identifying high-impact areas, then creating a prioritized plan that adapts as dependencies are discovered
Manage session state, resumption, and forking
  • Using --resume with session names to continue named investigation sessions across work sessions
  • Using fork_session to create parallel exploration branches (e.g., comparing two testing strategies or refactoring approaches from a shared codebase analysis)
  • Choosing between session resumption (when prior context is mostly valid) and starting fresh with injected summaries (when prior tool results are stale)
  • Informing a resumed session about specific file changes for targeted re-analysis rather than requiring full re-exploration
Tool Design & MCP Integration18%
Design effective tool interfaces with clear descriptions and boundaries
  • Writing tool descriptions that clearly differentiate each tool's purpose, expected inputs, outputs, and when to use it versus similar alternatives
  • Renaming tools and updating descriptions to eliminate functional overlap (e.g., renaming analyze_content to extract_web_results with a web-specific description)
  • Splitting generic tools into purpose-specific tools with defined input/output contracts (e.g., splitting a generic analyze_document into extract_data_points, summarize_content, and verify_claim_against_source)
  • Reviewing system prompts for keyword-sensitive instructions that might override well-written tool descriptions
Implement structured error responses for MCP tools
  • Returning structured error metadata including errorCategory (transient/validation/permission), isRetryable boolean, and human-readable descriptions
  • Including retriable: false flags and customer-friendly explanations for business rule violations so the agent can communicate appropriately
  • Implementing local error recovery within subagents for transient failures, propagating to the coordinator only errors that cannot be resolved locally along with partial results and what was attempted
  • Distinguishing between access failures (needing retry decisions) and valid empty results (representing successful queries with no matches)
Distribute tools appropriately across agents and configure tool choice
  • Restricting each subagent's tool set to those relevant to its role, preventing cross-specialization misuse
  • Replacing generic tools with constrained alternatives (e.g., replacing fetch_url with load_document that validates document URLs)
  • Providing scoped cross-role tools for high-frequency needs (e.g., a verify_fact tool for the synthesis agent) while routing complex cases through the coordinator
  • Using tool_choice forced selection to ensure a specific tool is called first (e.g., forcing extract_metadata before enrichment tools), then processing subsequent steps in follow-up turns
  • Setting tool_choice: "any" to guarantee the model calls a tool rather than returning conversational text
Integrate MCP servers into Claude Code and agent workflows
  • Configuring shared MCP servers in project-scoped .mcp.json with environment variable expansion for authentication tokens
  • Configuring personal/experimental MCP servers in user-scoped ~/.claude.json
  • Enhancing MCP tool descriptions to explain capabilities and outputs in detail, preventing the agent from preferring built-in tools (like Grep) over more capable MCP tools
  • Choosing existing community MCP servers over custom implementations for standard integrations (e.g., Jira), reserving custom servers for team-specific workflows
  • Exposing content catalogs as MCP resources to give agents visibility into available data without requiring exploratory tool calls
Select and apply built-in tools (Read, Write, Edit, Bash, Grep, Glob) effectively
  • Selecting Grep for searching code content across a codebase (e.g., finding all callers of a function, locating error messages)
  • Selecting Glob for finding files matching naming patterns (e.g., **/*.test.tsx)
  • Using Read to load full file contents followed by Write when Edit cannot find unique anchor text
  • Building codebase understanding incrementally: starting with Grep to find entry points, then using Read to follow imports and trace flows, rather than reading all files upfront
  • Tracing function usage across wrapper modules by first identifying all exported names, then searching for each name across the codebase
Claude Code Configuration & Workflows20%
Configure CLAUDE.md files with appropriate hierarchy, scoping, and modular organization
  • Diagnosing configuration hierarchy issues (e.g., a new team member not receiving instructions because they're in user-level rather than project-level configuration)
  • Using @import to selectively include relevant standards files in each package's CLAUDE.md based on maintainer domain knowledge
  • Splitting large CLAUDE.md files into focused topic-specific files in .claude/rules/ (e.g., testing.md, api-conventions.md, deployment.md)
  • Using the /memory command to verify which memory files are loaded and diagnose inconsistent behavior across sessions
Create and configure custom slash commands and skills
  • Creating project-scoped slash commands in .claude/commands/ for team-wide availability via version control
  • Using context: fork to isolate skills that produce verbose output (e.g., codebase analysis) or exploratory context (e.g., brainstorming alternatives) from the main session
  • Configuring allowed-tools in skill frontmatter to restrict tool access during skill execution (e.g., limiting to file write operations to prevent destructive actions)
  • Using argument-hint frontmatter to prompt developers for required parameters when they invoke the skill without arguments
  • Choosing between skills (on-demand invocation for task-specific workflows) and CLAUDE.md (always-loaded universal standards)
Apply path-specific rules for conditional convention loading
  • Creating .claude/rules/ files with YAML frontmatter path scoping (e.g., paths: ["terraform/**/*"]) so rules load only when editing matching files
  • Using glob patterns in path-specific rules to apply conventions to files by type regardless of directory location (e.g., **/*.test.tsx for all test files)
  • Choosing path-specific rules over subdirectory CLAUDE.md files when conventions must apply to files spread across the codebase
Determine when to use plan mode vs direct execution
  • Selecting plan mode for tasks with architectural implications (e.g., microservice restructuring, library migrations affecting 45+ files, choosing between integration approaches with different infrastructure requirements)
  • Selecting direct execution for well-understood changes with clear scope (e.g., a single-file bug fix with a clear stack trace, adding a date validation conditional)
  • Using the Explore subagent for verbose discovery phases to prevent context window exhaustion during multi-phase tasks
  • Combining plan mode for investigation with direct execution for implementation (e.g., planning a library migration, then executing the planned approach)
Apply iterative refinement techniques for progressive improvement
  • Providing 2-3 concrete input/output examples to clarify transformation requirements when natural language descriptions produce inconsistent results
  • Writing test suites covering expected behavior, edge cases, and performance requirements before implementation, then iterating by sharing test failures
  • Using the interview pattern to surface design considerations (e.g., cache invalidation strategies, failure modes) before implementing solutions in unfamiliar domains
  • Providing specific test cases with example input and expected output to fix edge case handling (e.g., null values in migration scripts)
  • Addressing multiple interacting issues in a single detailed message when fixes interact, versus sequential iteration for independent issues
Integrate Claude Code into CI/CD pipelines
  • Running Claude Code in CI with the -p flag to prevent interactive input hangs
  • Using --output-format json with --json-schema to produce machine-parseable structured findings for automated posting as inline PR comments
  • Including prior review findings in context when re-running reviews after new commits, instructing Claude to report only new or still-unaddressed issues to avoid duplicate comments
  • Providing existing test files in context so test generation avoids suggesting duplicate scenarios already covered by the test suite
  • Documenting testing standards, valuable test criteria, and available fixtures in CLAUDE.md to improve test generation quality and reduce low-value test output
Prompt Engineering & Structured Output20%
Design prompts with explicit criteria to improve precision and reduce false positives
  • Writing specific review criteria that define which issues to report (bugs, security) versus skip (minor style, local patterns) rather than relying on confidence-based filtering
  • Temporarily disabling high false-positive categories to restore developer trust while improving prompts for those categories
  • Defining explicit severity criteria with concrete code examples for each severity level to achieve consistent classification
Apply few-shot prompting to improve output consistency and quality
  • Creating 2-4 targeted few-shot examples for ambiguous scenarios that show reasoning for why one action was chosen over plausible alternatives
  • Including few-shot examples that demonstrate specific desired output format (location, issue, severity, suggested fix) to achieve consistency
  • Providing few-shot examples distinguishing acceptable code patterns from genuine issues to reduce false positives while enabling generalization
  • Using few-shot examples to demonstrate correct handling of varied document structures (inline citations vs bibliographies, methodology sections vs embedded details)
  • Adding few-shot examples showing correct extraction from documents with varied formats to address empty/null extraction of required fields
Enforce structured output using tool use and JSON schemas
  • Defining extraction tools with JSON schemas as input parameters and extracting structured data from the tool_use response
  • Setting tool_choice: "any" to guarantee structured output when multiple extraction schemas exist and the document type is unknown
  • Forcing a specific tool with tool_choice: {"type": "tool", "name": "extract_metadata"} to ensure a particular extraction runs before enrichment steps
  • Designing schema fields as optional (nullable) when source documents may not contain the information, preventing the model from fabricating values to satisfy required fields
  • Adding enum values like "unclear" for ambiguous cases and "other" + detail fields for extensible categorization
  • Including format normalization rules in prompts alongside strict output schemas to handle inconsistent source formatting
Implement validation, retry, and feedback loops for extraction quality
  • Implementing follow-up requests that include the original document, the failed extraction, and specific validation errors for model self-correction
  • Identifying when retries will be ineffective (e.g., information exists only in an external document not provided) versus when they will succeed (format mismatches, structural output errors)
  • Adding detected_pattern fields to structured findings to enable analysis of false positive patterns when developers dismiss findings
  • Designing self-correction validation flows: extracting "calculated_total" alongside "stated_total" to flag discrepancies, adding "conflict_detected" booleans for inconsistent source data
Design efficient batch processing strategies
  • Matching API approach to workflow latency requirements: synchronous API for blocking pre-merge checks, batch API for overnight/weekly analysis
  • Calculating batch submission frequency based on SLA constraints (e.g., 4-hour windows to guarantee 30-hour SLA with 24-hour batch processing)
  • Handling batch failures: resubmitting only failed documents (identified by custom_id) with appropriate modifications (e.g., chunking documents that exceeded context limits)
  • Using prompt refinement on a sample set before batch-processing large volumes to maximize first-pass success rates and reduce iterative resubmission costs
Design multi-instance and multi-pass review architectures
  • Using a second independent Claude instance to review generated code without the generator's reasoning context
  • Splitting large multi-file reviews into focused per-file passes for local issues plus separate integration passes for cross-file data flow analysis
  • Running verification passes where the model self-reports confidence alongside each finding to enable calibrated review routing
Context Management & Reliability15%
Manage conversation context to preserve critical information across long interactions
  • Extracting transactional facts (amounts, dates, order numbers, statuses) into a persistent "case facts" block included in each prompt, outside summarized history
  • Extracting and persisting structured issue data (order IDs, amounts, statuses) into a separate context layer for multi-issue sessions
  • Trimming verbose tool outputs to only relevant fields before they accumulate in context (e.g., keeping only return-relevant fields from order lookups)
  • Placing key findings summaries at the beginning of aggregated inputs and organizing detailed results with explicit section headers to mitigate position effects
  • Requiring subagents to include metadata (dates, source locations, methodological context) in structured outputs to support accurate downstream synthesis
  • Modifying upstream agents to return structured data (key facts, citations, relevance scores) instead of verbose content and reasoning chains when downstream agents have limited context budgets
Design effective escalation and ambiguity resolution patterns
  • Adding explicit escalation criteria with few-shot examples to the system prompt demonstrating when to escalate versus resolve autonomously
  • Honoring explicit customer requests for human agents immediately without first attempting investigation
  • Acknowledging frustration while offering resolution when the issue is within the agent's capability, escalating only if the customer reiterates their preference
  • Escalating when policy is ambiguous or silent on the customer's specific request (e.g., competitor price matching when policy only addresses own-site adjustments)
  • Instructing the agent to ask for additional identifiers when tool results return multiple matches, rather than selecting based on heuristics
Implement error propagation strategies across multi-agent systems
  • Returning structured error context including failure type, what was attempted, partial results, and potential alternatives to enable coordinator recovery
  • Distinguishing access failures from valid empty results in error reporting so the coordinator can make appropriate decisions
  • Having subagents implement local recovery for transient failures and only propagate errors they cannot resolve, including what was attempted and partial results
  • Structuring synthesis output with coverage annotations indicating which findings are well-supported versus which topic areas have gaps due to unavailable sources
Manage context effectively in large codebase exploration
  • Spawning subagents to investigate specific questions (e.g., "find all test files," "trace refund flow dependencies") while the main agent preserves high-level coordination
  • Having agents maintain scratchpad files recording key findings, referencing them for subsequent questions to counteract context degradation
  • Summarizing key findings from one exploration phase before spawning sub-agents for the next phase, injecting summaries into initial context
  • Designing crash recovery using structured agent state exports (manifests) that the coordinator loads on resume and injects into agent prompts
  • Using /compact to reduce context usage during extended exploration sessions when context fills with verbose discovery output
Design human review workflows and confidence calibration
  • Implementing stratified random sampling of high-confidence extractions for ongoing error rate measurement and novel pattern detection
  • Analyzing accuracy by document type and field to verify consistent performance across all segments before reducing human review
  • Having models output field-level confidence scores, then calibrating review thresholds using labeled validation sets
  • Routing extractions with low model confidence or ambiguous/contradictory source documents to human review, prioritizing limited reviewer capacity
Preserve information provenance and handle uncertainty in multi-source synthesis
  • Requiring subagents to output structured claim-source mappings (source URLs, document names, relevant excerpts) that downstream agents preserve through synthesis
  • Structuring reports with explicit sections distinguishing well-established findings from contested ones, preserving original source characterizations and methodological context
  • Completing document analysis with conflicting values included and explicitly annotated, letting the coordinator decide how to reconcile before passing to synthesis
  • Requiring subagents to include publication or data collection dates in structured outputs to enable correct temporal interpretation
  • Rendering different content types appropriately in synthesis outputs—financial data as tables, news as prose, technical findings as structured lists—rather than converting everything to a uniform format