# Certification Opening Brief

> Orients Claude Certified Architect — Foundations candidates to the exam blueprint: 720 passing score, five weighted domains, eight scenario families, target candidate profile, and how to navigate this repository's guides, PDFs, and practice assets as a structured study path with clear decision points before deep technical review.

- Repository: paullarionov/claude-certified-architect
- GitHub: https://github.com/paullarionov/claude-certified-architect
- Human wiki: https://grok-wiki.com/public/wiki/paullarionov-claude-certified-architect-1b20f95d81b9
- Complete Markdown: https://grok-wiki.com/public/wiki/paullarionov-claude-certified-architect-1b20f95d81b9/llms-full.txt

## Source Files

- `README.md`
- `guide_en.MD`
- `guide_es.md`
- `guide_ru.MD`
- `guide_zh.md`
- `pdf/guide_en.pdf`
- `image.png`
- `image-1.png`

---

<details>
<summary>Relevant source files</summary>
The following files were used as context for generating this wiki page:
- [README.md](README.md)
- [guide_en.MD](guide_en.MD)
- [guide_es.md](guide_es.md)
- [guide_ru.MD](guide_ru.MD)
- [guide_zh.md](guide_zh.md)
- [pdf/guide_en.pdf](pdf/guide_en.pdf)
- [practical_test_en.html](practical_test_en.html)
- [utils/build_practical_test_html.py](utils/build_practical_test_html.py)
- [image.png](image.png)
- [image-1.png](image-1.png)
</details>

# Certification Opening Brief

The **Claude Certified Architect — Foundations** (CCA-F) exam tests whether you can make sound trade-off decisions when building production Claude applications. This page orients you to the official blueprint—passing score, weighted domains, scenario families, and target candidate profile—and maps how this repository's guides, PDFs, and practice assets form a structured study path with clear decision points before you dive into deep technical review.

If you treat certification prep as a single long read-through, you will miss the exam's actual shape: 60 multiple-choice questions drawn from four randomly selected scenario families, scored on a 100–1000 scale where **720** is the passing threshold. This brief helps you decide *where to start*, *what to prioritize by weight*, and *when you are ready* for scenario drills and the timed practice exam.

---

## Exam Blueprint at a Glance

The official exam is a **120-minute proctored session** with **60 multiple-choice questions** (one correct answer out of four). Results arrive within two business days with section breakdowns. There is **no guessing penalty**—answer every question.

Sources: [guide_en.MD:29-36](), [image.png]()

| Parameter | Value |
|---|---|
| Question format | Multiple choice (1 of 4) |
| Scoring scale | 100–1000 |
| **Passing score** | **720** |
| Guessing penalty | None |
| Scenarios per exam | **4 of 8** (randomly selected) |
| Session length | 120 minutes, no external resources |

### Five Weighted Domains

Domain weighting tells you where to invest study time. Agent architecture carries the largest share; context management is smallest but still decisive at the margin.

Sources: [guide_en.MD:40-48]()

| # | Domain | Weight | Primary technologies |
|---|---|---|---|
| 1 | Agent architecture and orchestration | **27%** | Claude Agent SDK, coordinator/subagent patterns, hooks |
| 2 | Tool design and MCP integration | **18%** | MCP tools, `isError`, tool descriptions |
| 3 | Claude Code configuration and workflows | **20%** | CLAUDE.md, Skills, planning mode, CI integration |
| 4 | Prompt engineering and structured output | **20%** | JSON schemas, few-shot, `tool_use`, Batch API |
| 5 | Context management and reliability | **15%** | Escalation, error propagation, provenance, confidence |

**Study implication:** A candidate strong in Claude Code but weak in multi-agent orchestration is under-prepared for roughly half the exam (Domains 1 + 5 overlap heavily with scenario design). Weight domains, not just technologies.

---

## Target Candidate Profile

The ideal candidate is a **solution architect** with at least **six months** of hands-on experience shipping production Claude applications. The exam assumes you already work with:

- **Claude Agent SDK** — multi-agent orchestration, subagent delegation, tool integration, lifecycle hooks
- **Claude Code** — CLAUDE.md, MCP servers, Agent Skills, planning mode
- **Model Context Protocol (MCP)** — tools and resources for backend integration
- **Prompt engineering** — JSON schemas, few-shot examples, extraction templates
- **Context windows** — long documents, multi-agent context passing
- **CI/CD pipelines** — automated code review, test generation
- **Escalation and reliability** — error handling, human-in-the-loop

Sources: [guide_en.MD:15-25]()

### Self-Assessment Decision Point

Before opening Part I theory, honestly score yourself 1–5 on each bullet above. If three or more areas are below 3, complete the free Anthropic Academy courses listed in [README.md:49-65]() *before* scenario drills. The repository guide assumes practitioner familiarity; it teaches exam trade-offs, not beginner API syntax.

---

## Eight Scenario Families

The exam frames every question inside a realistic industry scenario. You will face **four of these eight** on test day. Each scenario stresses different domain combinations.

Sources: [guide_en.MD:52-76]()

| # | Scenario family | What you are architecting |
|---|---|---|
| 1 | Customer Support Agent | Returns, billing, account issues via Agent SDK + MCP tools (`get_customer`, `lookup_order`, `process_refund`, `escalate_to_human`); 80%+ first-contact resolution |
| 2 | Code Generation with Claude Code | Generation, refactoring, debugging, documentation; slash commands, CLAUDE.md, planning mode |
| 3 | Multi-Agent Research System | Coordinator delegates to web research, document analysis, synthesis, report generation with citations |
| 4 | Developer Productivity Tools | Codebase exploration, boilerplate, automation via built-in tools (Read, Write, Bash, Grep, Glob) + MCP |
| 5 | Claude Code for Continuous Integration | CI/CD code review, test generation, PR feedback; minimize false positives |
| 6 | Structured Data Extraction | Unstructured → structured via JSON schemas, edge cases, validation loops |
| 7 | Conversational AI Architecture Patterns | Multi-turn context, memory, safe tool execution, ambiguous inputs |
| 8 | Agentic AI Tools | **Content gap** — reported by candidates but not yet documented in this guide |

Scenario 8 is an explicit community gap. If you encounter it on the real exam, contribute details via [GitHub Issues](https://github.com/paullarionov/claude-certified-architect/issues) so the guide can close the coverage hole.

Sources: [guide_en.MD:75-76]()

### Scenario-to-Domain Mapping (Mental Model)

```text
┌─────────────────────────────────────────────────────────────────┐
│                     EXAM SESSION (4 of 8)                       │
├──────────────┬──────────────┬──────────────┬────────────────────┤
│  Scenario    │  Dominant    │  Secondary   │  Repo practice     │
│  family      │  domains     │  domains     │  coverage          │
├──────────────┼──────────────┼──────────────┼────────────────────┤
│ 1 Support    │ D1, D2       │ D5           │ Guide Qs + HTML ✓  │
│ 2 Code Gen   │ D3           │ D4           │ Guide Qs + HTML ✓  │
│ 3 Research   │ D1           │ D2, D5       │ Guide Qs + HTML ✓  │
│ 4 Dev Tools  │ D3, D2       │ D5           │ Guide only         │
│ 5 CI/CD      │ D3, D4       │ D5           │ Guide Qs + HTML ✓  │
│ 6 Extraction │ D4           │ D5           │ Guide + Exercise 3 │
│ 7 Conv. AI   │ D5, D4       │ D1           │ Guide theory       │
│ 8 Agentic    │ Unknown      │ Unknown      │ **Gap**            │
└──────────────┴──────────────┴──────────────┴────────────────────┘
```

The interactive `practical_test_en.html` currently drills **four** scenario families (15 questions each, 60 total): Customer Support, Multi-agent Research, Code Generation, and CI/CD. Scenarios 4, 6, 7, and 8 rely on guide content and practical exercises instead.

Sources: [practical_test_en.html:242](), [utils/build_practical_test_html.py:1-4]()

---

## Repository Study Path

This repository is a community study companion—not the official exam portal. Use it as a layered curriculum with explicit decision gates.

Sources: [README.md:1-47]()

```mermaid
flowchart TD
    subgraph entry [Entry]
        README[README.md]
        LANG{Preferred language?}
    end

    subgraph core [Core Guide — guide_*.md / pdf/]
        BLUEPRINT[Blueprint: domains + scenarios]
        PART1[PART I: Theory Foundations<br/>Chapters 1–9]
        PART2[PART II: Exam Domain Notes<br/>Domains 1–5]
        QUESTIONS[60 Worked Exam Questions]
        EXERCISES[Practical Exercises 1–4]
        APPENDIX[Appendix + Out-of-Scope]
    end

    subgraph practice [Practice Assets]
        HTML[practical_test_*.html]
        PDF[pdf/guide_*.pdf]
    end

    subgraph official [Official Access]
        PORTAL[anthropic.skilljar.com]
    end

    README --> LANG
    LANG -->|en, es, ru, zh, ja, …| BLUEPRINT
    BLUEPRINT --> PART1
    PART1 --> GATE1{6+ months<br/>hands-on?}
    GATE1 -->|No| ACADEMY[Anthropic Academy courses]
    GATE1 -->|Yes| PART2
    PART2 --> QUESTIONS
    QUESTIONS --> HTML
    EXERCISES --> HTML
    HTML --> GATE2{≥85% on<br/>practice test?}
    GATE2 -->|No| PART2
    GATE2 -->|Yes| PORTAL
    BLUEPRINT -.-> PDF
```

### Asset Guide

| Asset | Location | Best use |
|---|---|---|
| Language guides | `guide_en.MD`, `guide_es.md`, `guide_ru.MD`, `guide_zh.md`, + 6 more | Primary study text; identical blueprint across translations |
| Offline PDFs | `pdf/guide_*.pdf` | Auto-generated on merge; same content, portable reading |
| Interactive practice | `practical_test_en.html` (+ `ru`, `zh`, `ja`, `ko`) | Timed drill; scores wrong answers **by scenario** |
| Certificate reference | `image-1.png` | Visual example of earned credential |
| Official portal | [Skilljar access request](https://anthropic.skilljar.com/claude-certified-architect-foundations-access-request) | Exam registration (partner network required) |

Sources: [README.md:17-47](), [.github/workflows/markdown-to-pdf.yml]()

### Recommended Reading Order

**Phase 0 — Orient (this page + blueprint).** Read the Introduction, Target Candidate, Exam Format, Domains, and Scenarios sections at the top of your language guide. Skim the Official Documentation table for bookmarking.

**Phase 1 — Theory Foundations (Part I).** Nine chapters organized by technology (Claude API, tools, Agent SDK, MCP, Claude Code, prompt engineering, batches, decomposition, escalation)—*not* by exam domain. This builds the mental models Part II assumes.

Sources: [guide_en.MD:110-114]()

**Phase 2 — Domain Notes (Part II).** Re-read the same material through the exam's five-domain lens. Focus on **Key knowledge** and **Key skills** subsections—these mirror what section breakdowns likely measure.

Sources: [guide_en.MD:1511-1515]()

**Phase 3 — Scenario Questions.** Work through all 60 explained questions. Read *why* the correct answer wins and why each distractor fails—exam questions test trade-off reasoning, not trivia recall.

Sources: [guide_en.MD:1938]()

**Phase 4 — Practical Exercises.** Hands-on labs mapping to domains:

| Exercise | Focus | Domains |
|---|---|---|
| 1 — Multi-tool agent with escalation | Agent loop, MCP errors, hooks | 1, 2, 5 |
| 2 — Claude Code team config | CLAUDE.md, rules, skills, MCP | 3, 2 |
| 3 — Structured extraction pipeline | Schemas, validation, Batch API | 4, 5 |
| 4 — Multi-agent research pipeline | Coordinator, parallel Task, provenance | 1, 2, 5 |

Sources: [guide_en.MD:3283-3341]()

**Phase 5 — Timed Practice Exam.** Open `practical_test_en.html` in a browser. Complete all 60 questions in one sitting (mirrors the 120-minute official constraint). Review the per-scenario incorrect-answer summary to target weak families.

Sources: [README.md:45-47](), [guide_en.MD:3405]()

---

## Decision Points Before Deep Technical Review

Use these gates to avoid studying the wrong material at the wrong depth.

### Gate 1: Eligibility and Access

Certification is currently restricted to **Anthropic Partner Network** members with a verified partner company email. Free for the first 5,000 partner employees; general availability will be $99.

Sources: [README.md:11-15]()

**Decision:** If you lack partner access, you can still study from this repository, but you cannot schedule the proctored exam until approved. Apply via [claude.com/partners](https://claude.com/partners) if needed.

### Gate 2: Experience Baseline

**If < 6 months hands-on:** Start with Anthropic Academy courses (especially Agent Skills, MCP intro, Claude Code in Action, Building with the Claude API) before Part I chapters.

**If ≥ 6 months hands-on:** Skim Part I for gaps only; prioritize Part II domain notes weighted 27% and 20% domains.

Sources: [guide_en.MD:17](), [README.md:49-65]()

### Gate 3: Scenario Coverage Gap

Because only four scenarios appear per exam and the HTML practice test covers four families, you must **not** treat a high practice score as full readiness. Explicitly study guide questions for **Developer Productivity Tools**, **Structured Data Extraction**, and **Conversational AI Architecture Patterns** even though they are absent from the interactive test.

### Gate 4: Out-of-Scope Filter

Do not waste time on topics the guide explicitly excludes: fine-tuning, API billing, cloud-provider configs, streaming, computer use, vision, tokenization internals, and similar.

Sources: [guide_en.MD:3366-3385]()

### Gate 5: Exam-Day Strategy

| Situation | Recommended action |
|---|---|
| Unsure between two answers | Pick the best trade-off; no penalty for guessing |
| Question involves tool ordering | Prefer programmatic enforcement (hooks, preconditions) over prompt-only fixes |
| Multi-agent error handling | Return structured context to coordinator; never silently swallow failures |
| Conflicting source data | Preserve both values with attribution; escalate reconciliation to coordinator |
| Claude Code in CI | Use `-p` / `--print` for non-interactive mode; isolate review from generation session |

Sources: [guide_en.MD:34-35](), [guide_en.MD:1558-1566](), [guide_en.MD:1881-1891]()

---

## Worked Example: Exam-Style Reasoning Walkthrough

This walkthrough mirrors Scenario 3 (Multi-Agent Research System)—a family that appears in both the guide and the interactive practice test.

**Situation:** A document analysis agent discovers that two credible sources contain directly contradictory statistics for a key metric: a government report states 40% growth, while an industry analysis states 12%. Both sources look credible, and the discrepancy could materially affect the research conclusions.

**Question:** How should the document analysis agent handle this situation most effectively?

| Option | Approach | Verdict |
|---|---|---|
| A | Apply credibility heuristics; pick one number; footnote the discrepancy | ✗ Agent arbitrarily resolves conflict outside its scope |
| B | Include both numbers without marking conflict; let synthesis decide silently | ✗ Hides uncertainty; provenance lost |
| C | Stop analysis; immediately escalate to coordinator | ✗ Blocks core work; over-escalation |
| **D** | **Complete analysis with both numbers, explicit conflict annotation and source attribution; let coordinator reconcile before synthesis** | **✓ Correct** |

**Step-by-step reasoning:**

1. **Identify the agent's role boundary.** The document analysis agent extracts and reports; it does not adjudicate which government or industry source is authoritative.
2. **Apply the responsibility-separation pattern.** Complete core work without blocking; do not guess which statistic is correct.
3. **Preserve provenance.** Both values stay attached to their sources—critical for Domain 5 synthesis requirements.
4. **Route reconciliation upward.** The coordinator has broader context (other agents' findings, user goals) to resolve or present uncertainty.
5. **Reject distractors systematically.** A uses unreliable heuristics; B conceals conflict; C sacrifices throughput for a decision that belongs at coordination level.

Sources: [practical_test_en.html:242](), [guide_en.MD:1921-1934]()

This pattern—**complete locally, annotate uncertainty, delegate reconciliation**—recurs across scenarios. Recognizing it quickly is high-value exam prep.

---

## Domain Quick Reference: What Examiners Test

### Domain 1 — Agent Architecture (27%)

The highest-weight domain. Expect questions on agent loop lifecycle (`stop_reason` of `"tool_use"` vs `"end_turn"`), hub-and-spoke coordinator patterns, explicit subagent context passing via the `Task` tool, hooks for deterministic enforcement, and fixed vs adaptive task decomposition.

Sources: [guide_en.MD:1515-1603]()

### Domain 2 — Tool Design & MCP (18%)

Tool descriptions are the primary selection mechanism. Study `isError` semantics, structured error categories, renaming tools to eliminate overlap, and least-privilege tool interfaces.

Sources: [guide_en.MD:1607-1676]()

### Domain 3 — Claude Code (20%)

CLAUDE.md hierarchy, `.claude/rules/` path globs, Skills with `context: fork`, planning mode vs direct execution, and headless CI usage (`-p`, `--output-format json`).

Sources: [guide_en.MD:1678-1761]()

### Domain 4 — Prompt Engineering (20%)

Explicit criteria beat vague instructions; few-shot for ambiguous cases; `tool_use` + JSON Schema for guaranteed structure; Batch API economics; multi-pass review architectures.

Sources: [guide_en.MD:1764-1845]()

### Domain 5 — Context & Reliability (15%)

Escalation triggers (explicit human request, policy gaps, no progress), structured error propagation in multi-agent systems, scratchpad files, confidence calibration, and provenance preservation during synthesis.

Sources: [guide_en.MD:1849-1934]()

---

## Preparation Recommendations (From the Guide)

The guide's authors suggest eight concrete activities before exam day:

1. Build a full Agent SDK loop with tool calling, error handling, and session management
2. Configure Claude Code on a real project (CLAUDE.md hierarchy, rules, skills, MCP)
3. Design and test MCP tools with differentiated descriptions and structured errors
4. Build a data extraction pipeline with schemas, validation/retry, and Batch API
5. Practice few-shot prompting for ambiguous scenarios
6. Study context management (fact extraction, scratchpads, subagent delegation)
7. Understand escalation and human-in-the-loop patterns
8. **Take the practice exam** — same scenarios and format as the real test

Sources: [guide_en.MD:3389-3405]()

---

## Summary

The CCA-F exam rewards practitioners who make architecture trade-offs under realistic scenario pressure: **720** on a 100–1000 scale, **five weighted domains** (led by 27% agent architecture), and **four randomly drawn scenario families** from a pool of eight. This repository organizes prep into blueprint orientation, Part I theory, Part II domain notes, 60 worked questions, four hands-on exercises, multilingual PDFs, and an interactive 60-question practice test—use the decision gates above to sequence them efficiently.

Start with the blueprint sections of your preferred `guide_*.md`, validate your experience baseline, study all eight scenario families (not only the four in the HTML test), drill domain-weighted weak spots, then sit the timed practice exam. When you consistently score well and can articulate *why* each correct answer wins, you are ready to register through the official Skilljar portal and sit the 120-minute proctored session.

Sources: [README.md:43-47](), [guide_en.MD:29-48](), [guide_en.MD:3389-3405]()