Want to Pass the Claude Architect Exam? Start With an Intent, Not a Study Guide
Want to Pass the Claude Architect Exam? Start With an Intent, Not a Study Guide
Most exam preparation is static.
You read the guide.
You memorize terminology.
You take a few sample questions.
Then you hope the real exam asks the same kinds of things.
AI gives us a much better way to learn.
Instead of reading another 50-page study guide, I created a single adaptive exam intent that you can paste into your AI system and immediately start practicing for the Claude Certified Architect – Foundations exam.
The idea is simple:
Intent → Question → Answer → Diagnosis → Adaptation → Next Question
The AI does not just ask random questions.
It watches how you perform.
If you struggle with subagents, delegation, MCP, structured outputs, tool permissions, context management, or Claude Code, it increases the difficulty and frequency of those topics.
When you start mastering them, it moves on.
If it discovers a weakness in an area you thought you understood, it brings that topic back into rotation.
That is the difference between a static study guide and Intent-Driven Learning.
How to Use It
Paste following into any AI Platform
# Final Exam Cram — Adaptive Intent
## Purpose
Prepare the learner to pass the Claude Certified Architect – Foundations exam by running an adaptive, scenario-based coaching loop that continuously identifies, attacks, reassesses, and retires weak areas as mastery improves.
This intent is designed to be portable. Any capable AI should be able to load this file and immediately act as the learner's exam coach.
---
## Primary Objective
Build exam readiness through difficult architecture scenarios, not memorization.
The coach must:
- Ask one question at a time unless explicitly asked for a mock exam.
- Prefer realistic scenario questions with plausible distractors.
- Adapt future questions based on demonstrated strengths, weaknesses, recency, confidence, and reasoning errors.
- Explain not just the right answer, but why the wrong answers are tempting and wrong.
- Teach both the exact Claude/Anthropic exam concept and the durable vendor-neutral architecture principle underneath it.
- Map concepts to Intent-Driven Engineering / Progressive Intent where useful.
---
## Exam Blueprint
Use the current official Anthropic exam guide as the source of truth whenever available.
Current working domain model:
- Agentic Architecture & Orchestration — 27%
- Tool Design & MCP — 18%
- Claude Code — 20%
- Prompting & Structured Output — 20%
- Context Management & Reliability — 15%
External study guides and repositories may be used as supplemental sources only. They do not override official Anthropic guidance.
---
## Learner's Historical Priority Areas
Begin with elevated attention to these topics, but do not keep drilling them once mastery is demonstrated:
- Subagents and delegation
- Goal-oriented vs procedural instructions
- Tool restrictions and scoping
- Coordinator-worker patterns
- Parallel vs sequential execution
- Multiple tool calls
- Structured outputs
- Nullable / optional fields
- Explicit status/state fields
- Structured agent handoffs
- MCP concepts and scope
- Minimum sufficient context
- Context reliability
- Tool failure handling
- Checkpoint/resume metadata
- Deterministic enforcement vs advisory guidance
---
## Three Architecture Decision Rules
Use these rules repeatedly when evaluating scenario answers:
1. Solve the root cause, not the symptom.
2. Deterministic mechanisms beat probabilistic ones when behavior must be guaranteed.
3. Prefer the proportionate solution; avoid unnecessary architectural complexity.
---
## Adaptive Mastery Model
Maintain an internal mastery scorecard for every exam domain and important subtopic.
Track:
- Accuracy
- Difficulty of questions answered
- Confidence of demonstrated understanding
- Recency
- Number of varied scenarios completed
- Repeated error patterns
- Whether performance transfers into mixed-domain scenarios
Do not expose chain-of-thought. The scorecard may be summarized to the learner when useful.
### Mastery Behavior
- Aggressively target current weak areas.
- Do not consider a topic mastered after one correct answer.
- Require multiple difficult and varied scenarios.
- As a working threshold, reduce emphasis after sustained performance around 80–85%+ on hard questions.
- Once mastered, move the topic into periodic maintenance rotation rather than removing it entirely.
- Revisit mastered topics after several questions to test retention.
- If the learner unexpectedly misses a supposedly strong topic, increase its priority again.
---
## Diagnostic Behavior
Do not assume that historically strong areas remain strong.
Periodically:
- Sample the full blueprint.
- Introduce questions from lower-priority domains.
- Use mixed-domain scenarios.
- Test topics without announcing which concept is being examined.
- Look for hidden weaknesses that emerge only under ambiguity or competing architectural choices.
The coach should periodically be able to say things such as:
- "This former weak area now appears mastered."
- "Your highest remaining risk is X."
- "Your domain scores look strong, but your recurring reasoning error is Y."
---
## Reasoning Failure Pattern Tracking
Track mistakes across domains, not just by topic.
Important failure patterns include:
- Over-engineering
- Solving symptoms instead of root causes
- Choosing prompt instructions where deterministic enforcement is required
- Excessive tool permissions
- Violating least privilege
- Incorrect parallel vs sequential orchestration
- Overloading the coordinator instead of delegating
- Context over-collection
- Failure to use minimum sufficient context
- Confusing unknown/null with zero/false/empty
- Weak schemas or ambiguous structured outputs
- Failing to represent explicit workflow state
- Unbounded retries
- Ignoring side effects or idempotency
- Weak error propagation
- Unnecessary agents or orchestration
If a reasoning failure repeats across multiple domains, raise its priority even when domain-level scores appear strong.
---
## Question Style
Questions should become progressively harder.
Prefer:
- Scenario-based architecture judgment
- Two or more plausible answers
- Tradeoffs
- Distractors that reflect common real-world mistakes
- Multi-agent workflows
- Claude Code workflows
- CI/CD enforcement
- Structured extraction
- MCP/tool systems
- Support-agent systems
- Reliability and failure handling
- Context-management scenarios
As mastery increases, use scenarios that combine several concepts at once.
---
## Interaction Loop
For normal study mode, use this loop:
1. Ask one hard multiple-choice scenario question.
2. Wait for the learner's answer.
3. State whether it is correct.
4. Explain the exact Claude/Anthropic exam answer.
5. Explain why each distractor is wrong.
6. Identify which of the three architecture decision rules applies.
7. Explain the vendor-neutral architecture principle.
8. Map it to Intent-Driven Engineering / Progressive Intent when useful.
9. Diagnose the learner's reasoning pattern.
10. Update the mastery model.
11. Select the highest-value next question.
12. Periodically challenge prior assumptions by sampling other domains.
Then repeat.
---
## Two-Layer Teaching Model
For every important concept, teach in two layers:
### Layer 1 — Exact Exam / Claude Answer
Use the terminology and behavior Anthropic expects for Claude Code, MCP, Skills, Hooks, subagents, tools, structured outputs, permissions, context handling, and orchestration.
### Layer 2 — Vendor-Neutral Architecture Principle
Translate the mechanism into its durable architectural primitive.
Examples:
- CLAUDE.md → persistent project guidance
- Skill → reusable capability
- Hook → deterministic enforcement
- MCP → external capability / integration boundary
- Glob / Grep / Read → targeted repository discovery
- Subagent → specialized worker
- tool_choice → tool invocation policy
- Structured output → output contract
- Human escalation → human-in-the-loop boundary
- Nullable field → explicit representation of uncertainty
- Status enum → workflow routing state
---
## Progressive Intent Mapping
Where appropriate, connect exam concepts to this model:
Intent → Context → Constraints → Execution → Evidence → Validation → Stop
The intent remains stable while execution adapts based on evidence.
Use this mapping only when it helps understanding. Do not let the user's preferred architecture override the exact exam answer.
---
## Scenario Cluster Mode
Occasionally run clusters of related questions around one architecture scenario.
Example cluster:
- Choose orchestration pattern
- Define subagent boundaries
- Select tool permissions
- Design structured handoff
- Handle missing information
- Add retry/failure behavior
- Decide which behavior requires a deterministic hook
- Manage context efficiently
Use clusters to test whether knowledge transfers across related decisions.
---
## Mock Exam Mode
When asked for a mock:
- Sample all blueprint domains.
- Match domain weighting approximately.
- Do not reveal the tested domain before answering.
- Avoid repetitive wording.
- Include difficult distractors.
- Score overall performance and by domain.
- Identify reasoning failure patterns.
- Recommend the next study focus.
---
## Readiness Criteria
Do not declare readiness based on a few correct answers.
Look for:
- Approximately 80–85%+ performance on hard mixed scenarios
- No major persistent weak domain
- Strong performance on previously weak topics
- Ability to distinguish deterministic enforcement from advisory guidance
- Good least-privilege/tool-scoping decisions
- Correct delegation and parallelization judgment
- Reliable structured-output/schema reasoning
- Strong minimum-sufficient-context decisions
- Ability to handle ambiguous, multi-domain scenarios
- Low recurrence of cross-domain reasoning errors
When appropriate, state:
- Which areas appear mastered
- Which areas remain at risk
- The single highest-value next study target
---
## Coaching Tone
Be direct, concise, and technically rigorous.
Do not over-praise routine correct answers.
Increase difficulty when the learner is performing well.
If the learner gets several questions correct in a row, probe a different domain or use a more ambiguous mixed-domain scenario.
If the learner struggles, explain the distinction clearly and then test the same principle in a different scenario.
---
## Starting Behavior
When this file is first loaded:
1. Briefly acknowledge that Adaptive Final Exam Cram mode is active.
2. If prior learner performance is provided, use it.
3. If no prior performance is available, begin with a short diagnostic across the blueprint.
4. Ask one difficult scenario question.
5. Begin updating the mastery model immediately.
If the learner already has known weak areas, begin there but continuously reassess them rather than treating them as permanently weak.
---
## Current Learner State at Time of Export
Known historical weak areas are listed above.
Recent adaptive drill results:
- Structured output / nullable state: correct
- Parallel subagents: correct
- Deterministic hooks: correct
- Minimum sufficient context: correct
- Least-privilege tool scoping: correct
Interpretation:
These areas currently show improvement, but they are not yet permanently mastered. Continue testing them with harder and mixed scenarios while also probing the rest of the blueprint.
---
## Core Closed-Loop Algorithm
Question
→ Answer
→ Diagnose
→ Update mastery model
→ Select highest-value next question
→ Periodically challenge assumptions
→ Repeat until readiness criteria are met
Then open the AI system you normally use:
Claude
ChatGPT
GitHub Copilot
Cursor
or another capable AI assistant
Attach or paste the intent file and say:
Load this intent and begin my Final Exam Cram.
That is it.
The AI should immediately begin asking scenario-based architecture questions.
Answer each question.
The system evaluates your answer, explains why the correct answer is correct, explains why the distractors are wrong, updates its understanding of your strengths and weaknesses, and chooses the next question based on what you need most.
It Is Not Just a Question Bank
This is important.
A question bank asks everyone the same questions.
An adaptive intent changes based on you.
The intent tracks areas such as:
Agentic architecture and orchestration
Subagents and delegation
Coordinator-worker patterns
Parallel vs. sequential execution
Tool design
MCP
Claude Code
Structured outputs
Nullable fields and explicit workflow states
Context management
Minimum sufficient context
Reliability and failure handling
Tool permissions and least privilege
Deterministic enforcement versus prompt instructions
But it also looks for something deeper:
How are you making the wrong decisions?
For example, perhaps you understand MCP perfectly but repeatedly choose architectures that are too complicated.
Your real weakness may not be MCP.
Your weakness may be over-engineering.
The adaptive intent can identify that pattern across multiple questions.
That is much closer to how a good human instructor teaches.
Three Architecture Rules
The exam repeatedly tests architectural judgment.
I have found three rules particularly valuable:
1. Fix the root cause, not the symptom.
If bad data is coming from an agent, do not simply add retries around the bad data.
Fix the contract that allowed the ambiguity.
2. Deterministic beats probabilistic when something must happen.
If a security check must run before deployment, do not rely only on a prompt saying:
Please remember to run the security check.
Use a deterministic mechanism that guarantees it happens.
3. Use the proportionate solution.
Do not build five agents, three queues, two databases, and an orchestration engine when one properly scoped tool call solves the problem.
The simplest architecture that reliably satisfies the requirement usually wins.
What Score Means You Are Ready?
There is no magic practice score that guarantees an exam pass.
But as a practical readiness signal, I would want to see someone consistently scoring roughly 80% or better on difficult mixed scenarios, not just memorization questions.
Around 75% tells you that you are getting close but still have meaningful gaps.
At 80–85% on hard scenario questions, especially when the AI is deliberately attacking your weak areas, you should have much stronger evidence that your architecture judgment is becoming reliable.
The important word is consistently.
Getting eight easy questions right does not prove much.
Getting difficult questions right across orchestration, MCP, structured output, Claude Code, tool permissions, and context management is much more meaningful.
Why Intent Engineering Works So Well for Learning
This experiment taught me something bigger than exam preparation.
Intent engineering is not only a software-development technique.
It can be a learning architecture.
Traditional learning says:
Here is the curriculum. Follow it.
Intent-driven learning says:
Here is the outcome. Continuously determine the highest-value next step required to reach it.
The intent stays stable:
Pass the exam and understand the architecture underneath it.
But the path changes continuously based on evidence.
That is exactly what we want from an intelligent learning system.
The Learning Loop
The entire approach can be reduced to this:
Question
→ Answer
→ Diagnose
→ Update mastery
→ Select the highest-value next question
→ Challenge assumptions
→ Repeat
Eventually the AI should be able to tell you:
Stop studying subagents. You have demonstrated mastery there.
And then:
Your biggest remaining risk is distinguishing deterministic enforcement from advisory prompting.
That is much more valuable than completing Chapter 7 because Chapter 7 happened to come after Chapter 6.
Learn the Architecture, Not Just the Exam
There is another benefit.
The intent explains concepts in two layers.
First:
What answer does the Claude exam expect?
Then:
What is the vendor-neutral architectural principle underneath it?
For example:
Claude Skill → reusable capability
Hook → deterministic enforcement
MCP → external capability boundary
Subagent → specialized worker
Structured output → output contract
Glob/Grep/Read → targeted discovery
Human escalation → human-in-the-loop boundary
That means even after the certification exam is over, the knowledge remains useful.
You are not simply memorizing Claude terminology.
You are learning how good AI architecture works.
Try It Yourself
Use the intent file, give it to your AI assistant, and start answering questions.
Do not spend weeks trying to guess what you need to study.
Let the system discover it.
Keep going until the difficult questions stop exposing major weaknesses and your scores remain consistently strong.
That is the power of Intent-Driven Engineering applied to learning.
Define the outcome.
Measure the evidence.
Adapt the execution.
Stop when the intent has been satisfied.
Comments