Ace the Claude Certified Architect exam Adaptive certification prep powered by the Model Context Protocol. 390 questions. Guided capstone build. 30 concept handouts. 6 reference projects. Practice exams. Spaced repetition. Zero sycophancy. Quick Start • Features • How It Works • Study Modes • Capstone Build • Reference Projects • Concept Handouts • Exam Domains • Architecture Architect Cert is a f
Add this skill
npx mdskills install connectry-io/connectrylab-architect-cert-mcpComprehensive certification prep with 390 questions, spaced repetition, and zero sycophancy
Ace the Claude Certified Architect exam
Adaptive certification prep powered by the Model Context Protocol.
390 questions. Guided capstone build. 30 concept handouts. 6 reference projects. Practice exams. Spaced repetition. Zero sycophancy.
Quick Start • Features • How It Works • Study Modes • Capstone Build • Reference Projects • Concept Handouts • Exam Domains • Tools • Architecture
Architect Cert is a free, open-source MCP server that turns Claude into your personal certification tutor for the Claude Certified Architect — Foundations exam. No courses, no slides, no video lectures — just ask Claude and study.
It ships with:
Everything runs locally. No cloud, no accounts, no telemetry.
npm install -g connectry-architect-mcp
Claude Code (VS Code / Cursor / Terminal)
Add to .mcp.json in your project or ~/.claude.json globally:
{
"mcpServers": {
"connectry-architect": {
"command": "connectry-architect-mcp"
}
}
}
Then restart Claude Code. The server starts automatically when Claude loads.
Claude Desktop — macOS
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"connectry-architect": {
"command": "connectry-architect-mcp"
}
}
}
Restart Claude Desktop. You'll see the MCP tools icon appear in the chat input.
Claude Desktop — Windows
Add to %APPDATA%\Claude\claude_desktop_config.json:
{
"mcpServers": {
"connectry-architect": {
"command": "connectry-architect-mcp"
}
}
}
Restart Claude Desktop. You'll see the MCP tools icon appear in the chat input.
Any MCP-compatible client
Architect Cert works with any client that supports the Model Context Protocol. Configure it as a stdio server:
connectry-architect-mcpThe server exposes 17 tools, 8 prompts, and 3 resource types.
Restart your MCP client and start chatting:
| What you want | What to ask Claude |
|---|---|
| Find your weak areas | "Start an assessment to figure out where I stand" |
| Practice questions | "Give me a practice question" |
| Focus on a domain | "Give me a question about agentic architecture" |
| Learn a concept first | "Teach me about task 2.3 — tool provisioning" |
| Build your own capstone | "I want to start a guided capstone build" |
| Take a practice exam | "I want to take a practice exam" |
| Check your progress | "Show my study progress" |
| Get a study plan | "What should I study next?" |
| Explore a reference project | "Show me a reference project for domain 1" |
| Generate PDF handouts | Run npm run generate:pdfs in the project directory |
| Reset and start over | "Reset my progress" |
SM-2 spaced repetition resurfaces weak areas at optimal intervals. Questions you get wrong come back sooner — questions you master fade away.
13 scenario-based questions per task statement across all 30 topics. Easy, medium, and hard difficulties with balanced answer distributions across A/B/C/D.
Pure function grading — no LLM judgment calls. Your answer is checked against a verified key. Right is right, wrong is wrong. Every wrong answer includes a specific explanation.
Claude won't sugarcoat wrong answers. Anti-sycophancy rules are enforced at the protocol level. Wrong means wrong — no "you were on the right track."
Persistent SQLite database tracks every answer, mastery level, and review schedule. Pick up exactly where you left off across sessions, devices, and MCP clients.
Three-priority algorithm: overdue reviews first, then weak areas, then new material. You always work on what matters most for exam readiness.
After every answer, you get follow-up options. Got it wrong? Choose to see a code example, read the concept lesson, open the handout, or explore the relevant reference project — then jump back to your quiz.
Shape your own project idea, then build it file-by-file across 18 steps. Each step: quiz on the relevant task statements, Claude generates themed code, then a walkthrough explains how every section maps to exam concepts. Learn by doing.
Every task statement has a structured handout: concept explanation, TypeScript code example, common mistakes, and documentation references. Available as markdown in Claude or as branded PDFs for offline study.
Runnable TypeScript codebases that demonstrate each domain in practice. A capstone project ties all 5 domains together. Each file maps to specific task statements so you can see concepts in real code.
Full 60-question exams weighted by domain — just like the real certification. Fresh questions each time (no repetition from your last attempt). Scored out of 1000, passing at 720. All attempts saved with per-domain breakdowns.
Generate branded PDFs for all 30 handouts with npm run generate:pdfs. Each PDF includes the Architect Cert logo, domain label, and clean formatting for printing or tablet reading.
┌──────────────────────────────────────────────────────────────────┐
│ YOUR MACHINE │
│ │
│ ┌──────────────┐ ┌──────────────────────────┐ │
│ │ Claude Desktop│ │ Architect Cert MCP │ │
│ │ Claude Code │◄─────►│ │ │
│ │ Any MCP client│ stdio │ 17 tools │ │
│ └──────────────┘ │ 8 prompts │ │
│ │ 3 resource types │ │
│ └──────────┬───────────────┘ │
│ │ │
│ ┌─────────────────┼─────────────────┐ │
│ │ │ │ │
│ ~/.connectry- 390 questions 6 reference │
│ architect/ 30 handouts projects │
│ progress.db (bundled JSON/MD) (bundled TS) │
│ │
└──────────────────────────────────────────────────────────────────┘
The study loop:
Data storage:
~/.connectry-architect/progress.db (SQLite, WAL mode)~/.connectry-architect/config.json (auto-created on first run)Start with 15 questions across all domains. Based on your score:
Before tackling questions on any topic, you can read the concept handout first:
You: "Teach me about task 1.5 — tool-use hooks"
Claude: [loads the concept handout with key concepts, code examples,
common mistakes, and documentation references]
Ready to test your understanding? I have 13 questions
on this topic ranging from easy to hard.
The server tracks which handouts you've viewed. You can always come back to them later.
After every answer, you get contextual follow-up options:
After a wrong answer:
The correct answer is B. [explanation]
> Got it, next question
> Explain with a code example
> Show me the concept lesson
> Show me the handout
> Show me in the reference project
After a correct answer:
Correct!
> Next question
> Explain why the others are wrong
Each option dives deeper into the concept — then brings you right back to your quiz. This means you never have to leave your study flow to look something up.
Every question is selected by a three-priority algorithm:
Full 60-question exams that simulate the real certification:
| Detail | Value |
|---|---|
| Total questions | 60 |
| D1: Agentic Architecture | 16 questions (27%) |
| D2: Tool Design & MCP | 11 questions (18%) |
| D3: Claude Code Config | 12 questions (20%) |
| D4: Prompt Engineering | 12 questions (20%) |
| D5: Context & Reliability | 9 questions (15%) |
| Scoring | 0–1000, passing at 720 |
| Question selection | Fresh set each time — avoids repeating your most recent attempt |
All attempts are saved with per-domain score breakdowns and improvement trends.
Each of the 30 task statements has an independent mastery level:
| Level | Criteria | What it means |
|---|---|---|
| Unassessed | No attempts yet | You haven't seen questions on this topic |
| Weak | = 90% accuracy, 5+ attempts, 3+ consecutive correct | Exam-ready — rare reviews |
The SM-2 algorithm schedules review intervals:
Difficult questions come back often. Easy ones space out to weeks or months.
The most hands-on way to learn — build your own project from scratch while covering all 30 task statements. Instead of just answering questions, you architect a real system themed to your own idea.
The capstone build has three phases:
Phase 1 — Project Shaping
You describe a project idea (e.g., "a multi-agent code review system"). Claude analyzes your idea against all 30 architectural criteria and identifies gaps. You refine together until every task statement is covered.
You: "I want to start a guided capstone build"
Claude: [presents the 30 criteria across all 5 domains]
Describe your project idea and I'll analyze coverage.
You: "A multi-agent code review system that analyzes PRs"
Claude: Your idea naturally covers 24/30 criteria. To cover the
remaining 6, I'd suggest adding: [specific suggestions
mapped to task statements]
Phase 2 — Interleaved Build (18 steps)
Each step follows the same pattern:
The 18 steps build incrementally:
| Steps | What you build | Task Statements |
|---|---|---|
| 1-2 | Project config (CLAUDE.md, package.json) | 3.1-3.4 |
| 3-5 | MCP server, tools, error handling | 2.1-2.5 |
| 6-10 | Agentic loop, subagents, hooks, workflows, sessions | 1.1-1.7 |
| 11-13 | Prompts: system, extraction, batch processing | 4.1-4.6 |
| 14-18 | Context: preservation, triggers, propagation, scratchpad, confidence | 5.1-5.6 |
Every quiz answer feeds into the same spaced repetition and mastery tracking as regular practice.
Phase 3 — Final Review
After step 18, you get a complete coverage map: all 30 task statements, where each is demonstrated in your project, and your quiz performance per domain. Weak areas are flagged for further study.
| Tool | What it does |
|---|---|
start_capstone_build | See the 30 criteria, describe your theme, refine until coverage is complete |
capstone_build_step | Drive the build: confirm, quiz, build, next, status, or abandon |
capstone_build_status | Check your progress — current step, criteria coverage, quiz performance |
submit_answer grading and SM-2 schedulingArchitect Cert includes 6 complete reference projects — runnable TypeScript codebases that demonstrate certification concepts in real code. Every file has a header comment mapping it to specific task statements.
| Project | Focus | Files | What You'll See |
|---|---|---|---|
| Capstone | All 5 domains | 24 | Full multi-agent support system with MCP server, coordinator, subagents, prompt engineering, context management, and hooks |
| D1 — Agentic Loop | Domain 1 | 10 | Multi-agent research coordinator with agentic loops, subagent spawning, hooks, session management, and task decomposition |
| D2 — Tool Design | Domain 2 | 12 | MCP server with split tools, structured errors, agent-scoped tool distribution, resources, and built-in tool patterns |
| D3 — Claude Code Config | Domain 3 | 14 | Complete config reference: CLAUDE.md hierarchy, slash commands, path rules, CI/CD workflows — not runnable code, but a real config layout |
| D4 — Prompt Engineering | Domain 4 | 11 | Data extraction pipeline with explicit criteria, few-shot, structured output, validation-retry, batch processing, and multi-pass review |
| D5 — Context Manager | Domain 5 | 14 | Long-session patterns: context preservation, scratchpad, subagent delegation, escalation, error propagation, confidence calibration, provenance |
Ask Claude:
You: "Show me a reference project for domain 1"
Claude: [calls scaffold_project, returns the project README,
file listing, and architecture walkthrough]
Or browse them directly in the repo under projects/.
When you get a question wrong, one of the follow-up options is "Show me in the reference project" — this takes you straight to the relevant domain project so you can see the concept implemented in real code. Then you jump back to your quiz.
Every task statement has a concept handout — a structured study document (~500-800 words) that covers:
You: "Show me the handout for task 2.3"
Claude: [loads the full handout with concept, code, mistakes, references]
You can generate branded PDFs for all 30 handouts for offline study:
cd connectrylab-architect-cert-mcp
npm run generate:pdfs
This creates 30 PDFs in generated/handouts/ with:
The Claude Certified Architect — Foundations exam covers 5 domains:
| # | Domain | Weight | Tasks | Questions |
|---|---|---|---|---|
| 1 | Agentic Architecture & Orchestration | 27% | 7 | 91 |
| 2 | Tool Design & MCP Integration | 18% | 5 | 65 |
| 3 | Claude Code Configuration & Workflows | 20% | 6 | 78 |
| 4 | Prompt Engineering & Structured Output | 20% | 6 | 78 |
| 5 | Context Management & Reliability | 15% | 6 | 78 |
| Total | 100% | 30 | 390 |
Domain 1 — Agentic Architecture & Orchestration (7 tasks, 91 questions)
| Task | Description |
|---|---|
| 1.1 | Design and implement agentic loops for autonomous task execution |
| 1.2 | Orchestrate multi-agent systems with coordinator-subagent patterns |
| 1.3 | Configure subagent invocation, context passing, and spawning |
| 1.4 | Implement multi-step workflows with enforcement and handoff patterns |
| 1.5 | Apply Agent SDK hooks for tool call interception and data normalization |
| 1.6 | Design task decomposition strategies for complex workflows |
| 1.7 | Manage session state, resumption, and forking |
Domain 2 — Tool Design & MCP Integration (5 tasks, 65 questions)
| Task | Description |
|---|---|
| 2.1 | Design effective tool interfaces with clear descriptions and boundaries |
| 2.2 | Implement structured error responses for MCP tools |
| 2.3 | Distribute tools appropriately across agents and configure tool choice |
| 2.4 | Integrate MCP servers into Claude Code and agent workflows |
| 2.5 | Select and apply built-in tools effectively |
Domain 3 — Claude Code Configuration & Workflows (6 tasks, 78 questions)
| Task | Description |
|---|---|
| 3.1 | Configure CLAUDE.md files with appropriate hierarchy and scoping |
| 3.2 | Create and configure custom slash commands and skills |
| 3.3 | Apply path-specific rules for conditional convention loading |
| 3.4 | Determine when to use plan mode vs direct execution |
| 3.5 | Apply iterative refinement techniques for progressive improvement |
| 3.6 | Integrate Claude Code into CI/CD pipelines |
Domain 4 — Prompt Engineering & Structured Output (6 tasks, 78 questions)
| Task | Description |
|---|---|
| 4.1 | Design prompts with explicit criteria to improve precision |
| 4.2 | Apply few-shot prompting to improve output consistency |
| 4.3 | Enforce structured output using tool use and JSON schemas |
| 4.4 | Implement validation, retry, and feedback loops |
| 4.5 | Design efficient batch processing strategies |
| 4.6 | Design multi-instance and multi-pass review architectures |
Domain 5 — Context Management & Reliability (6 tasks, 78 questions)
| Task | Description |
|---|---|
| 5.1 | Manage conversation context to preserve critical information |
| 5.2 | Design effective escalation and ambiguity resolution patterns |
| 5.3 | Implement error propagation strategies across multi-agent systems |
| 5.4 | Manage context effectively in large codebase exploration |
| 5.5 | Design human review workflows and confidence calibration |
| 5.6 | Preserve information provenance and handle uncertainty in synthesis |
Architect Cert provides 17 MCP tools that Claude uses to deliver the study experience:
| Tool | Description |
|---|---|
start_assessment | Begin with 15 diagnostic questions to determine your learning path |
get_practice_question | Get the next adaptive question (reviews > weak areas > new material) |
submit_answer | Grade your answer deterministically — includes interactive follow-up options |
follow_up | Handle post-answer actions: code examples, concept lessons, handouts, reference projects |
get_progress | View overall study progress with mastery percentages per domain |
get_curriculum | Browse all 5 domains and 30 task statements with current mastery levels |
get_section_details | Deep dive into a specific task statement with concept lesson |
get_weak_areas | Identify topics that need the most work, ranked by weakness |
get_study_plan | Get personalized recommendations based on performance and exam weights |
start_practice_exam | Take a full 60-question practice exam simulating the real certification |
submit_exam_answer | Submit and grade answers during a practice exam |
get_exam_history | View all past exam attempts with scores, trends, and per-domain comparison |
scaffold_project | Access reference projects for hands-on practice with real code |
start_capstone_build | Start a guided capstone build — shape your project and validate criteria coverage |
capstone_build_step | Drive the capstone build: confirm, quiz, build, next, status, or abandon |
capstone_build_status | Check capstone build progress — current step, coverage, quiz performance |
reset_progress | Start over — requires explicit confirmation to prevent accidents |
The server also registers 8 interactive prompts and 3 resource types (concept handouts, reference projects, exam overview).
Claude (UI) MCP Server (stdio) Core Engine SQLite
| Component | Technology | Purpose |
|---|---|---|
| MCP Server | @modelcontextprotocol/sdk v1 | Registers tools, prompts, resources over stdio |
| Grading Engine | Pure TypeScript functions | Deterministic answer verification |
| Spaced Repetition | SM-2 algorithm | Optimal review scheduling |
| Follow-Up System | State-driven tool chain | Interactive post-answer detours |
| Capstone Build Engine | 18-step interleaved builder | Guided learn-build-explain flow with LLM validation |
| Question Bank | 390 bundled JSON questions | Scenario-based, verified against docs |
| Concept Handouts | 30 bundled markdown files | Structured study materials per task statement |
| Reference Projects | 6 bundled TypeScript projects | Runnable code demonstrating each domain |
| PDF Generator | pdfkit | Branded handout PDFs for offline study |
| Progress Store | better-sqlite3 (WAL mode) | Persistent mastery, answers, schedules |
This server enforces honest grading at the protocol level — not just in prompts:
gradeAnswer() is a pure function. No LLM is involved in judging correctness.submit_answer tool description instructs Claude to relay results verbatim.whyWrongMap entry explaining the misconception.| Metric | Value |
|---|---|
| Total questions | 390 |
| Domains covered | 5 |
| Task statements covered | 30 |
| Questions per task statement | 13 |
| Difficulty distribution | ~4 easy, 5 medium, ~4 hard per task |
| Answer key balance | Distributed across A/B/C/D |
| Question format | Scenario-based multiple choice |
| Each question includes | Scenario, question, 4 options, explanation, why-wrong-map, references |
| Source material | Anthropic official documentation |
We welcome contributions! Here's how to get started:
# Clone the repo
git clone https://github.com/Connectry-io/connectrylab-architect-cert-mcp.git
cd connectrylab-architect-cert-mcp
# Install dependencies
npm install
# Build
npm run build
# Run tests (30 tests across 6 test files)
npm test
# Generate PDF handouts
npm run generate:pdfs
# Run locally
node dist/index.js
src/
├── index.ts # MCP server entry point
├── config.ts # User config management
├── types.ts # All TypeScript interfaces
├── data/
│ ├── loader.ts # Lazy-cached data loading
│ ├── curriculum.json # 30 task statements
│ ├── questions/ # 390 questions (5 domain files)
│ ├── handouts/ # 30 concept handouts (markdown)
│ ├── criteria.ts # 30 task statement criteria for capstone validation
│ ├── build-steps.ts # 18 capstone build step definitions
│ └── system-prompt.ts # Anti-sycophancy rules
├── db/
│ ├── schema.ts # SQLite schema (9 tables)
│ ├── store.ts # Database initialization
│ ├── mastery.ts # Mastery level calculations
│ ├── answers.ts # Answer recording
│ ├── capstone.ts # Capstone build CRUD operations
│ └── exam-attempts.ts # Practice exam tracking
├── engine/
│ ├── grading.ts # Deterministic grading
│ ├── spaced-repetition.ts # SM-2 algorithm
│ ├── question-selector.ts # Priority-based selection
│ ├── exam-builder.ts # Practice exam generation
│ └── adaptive-path.ts # Learning path recommendations
├── tools/ # 17 MCP tool handlers
├── prompts/ # 8 MCP prompt definitions
└── resources/ # 3 MCP resource types
projects/
├── capstone/ # All 5 domains — multi-agent support system
├── d1-agentic/ # Domain 1 — agentic loop research coordinator
├── d2-tools/ # Domain 2 — MCP server with tool patterns
├── d3-config/ # Domain 3 — Claude Code configuration layout
├── d4-prompts/ # Domain 4 — extraction & prompt engineering
└── d5-context/ # Domain 5 — context management & reliability
scripts/
└── generate-pdfs.ts # PDF handout generator
MIT © Connectry Labs
Built with care by Connectry Labs
Install via CLI
npx mdskills install connectry-io/connectrylab-architect-cert-mcpArchitect Cert MCP is a free, open-source AI agent skill. Ace the Claude Certified Architect exam Adaptive certification prep powered by the Model Context Protocol. 390 questions. Guided capstone build. 30 concept handouts. 6 reference projects. Practice exams. Spaced repetition. Zero sycophancy. Quick Start • Features • How It Works • Study Modes • Capstone Build • Reference Projects • Concept Handouts • Exam Domains • Architecture Architect Cert is a f
Install Architect Cert MCP with a single command:
npx mdskills install connectry-io/connectrylab-architect-cert-mcpThis downloads the skill files into your project and your AI agent picks them up automatically.
Architect Cert MCP works with Claude Code, Claude Desktop, Cursor, Vscode Copilot, Windsurf, Continue Dev, Gemini Cli, Amp, Roo Code, Goose. Skills use the open SKILL.md format which is compatible with any AI coding agent that reads markdown instructions.