Claude Architect Certification: The 60-Article Field Guide

Claude Architect Certification: The 60-Article Field Guide

This is the capstone.

Sixty articles.

One preparation arc.

The goal was never to memorize random Claude Code features.

The goal was to build an architect’s mental model.

That is the whole game.

A developer asks:

“Can Claude build this?”

An architect asks:

“Can Claude build this safely, repeatedly, with the right context, the right controls, the right evidence, and a clear delivery decision?”

That is the mindset.

That is what this 60-article series has been building toward.

The Big Idea of the Entire Series

The whole series can be reduced to one operating loop:

Intent → Context → Plan → Build → Validate → Evidence → Pull Request → Release Decision

That loop is the backbone.

It applies to Claude Code.

It applies to agentic workflows.

It applies to enterprise delivery.

It applies to Intent-Driven Engineering.

And it applies to the exam.

Claude Code is currently described by Anthropic as an agentic coding tool that can read a codebase, edit files, run commands, and integrate with development tools. That means the architect has to think beyond prompting. Claude Code becomes part of the engineering system itself.

The question is not whether the tool can act.

The question is whether the architecture makes that action safe, useful, repeatable, and reviewable.

The 60-Article Map

The 60 articles naturally fall into six major blocks.

Articles 1–10: Foundations

The first block established the basic shift from traditional engineering to AI-assisted engineering.

The main ideas:

• Claude Code is not just autocomplete.

• Intent matters more than loose prompting.

• Context matters more than clever wording.

• Architects must think in systems, not tasks.

• AI engineering is not magic. It is process, context, controls, and feedback.

The foundation is simple:

Claude is only as useful as the engineering system around it.

Articles 11–20: Claude Code and the Working Repo

The second block moved into practical Claude Code usage.

The main ideas:

• Claude Code works best when it understands the repo.

• Repo structure, conventions, tests, setup commands, and existing patterns matter.

• CLAUDE.md and project memory are essential.

• Claude should inspect before it changes.

• A good workflow starts with context gathering, not blind implementation.

Anthropic’s memory docs describe CLAUDE.md files as a way to give Claude persistent project instructions, with auto memory helping carry learnings across sessions. That makes memory an architectural tool, not just a convenience.

The key exam idea:

Do not let the agent guess what the repo already knows. Put durable project context where Claude can use it.

Articles 21–30: Agents, Subagents, and Workflows

The third block focused on agentic engineering.

The main ideas:

• Agents should not be vague.

• Subagents should have specific roles.

• Delegation should match responsibility.

• Workflows should be staged and reviewable.

• Bigger is not always better.

• A simple Claude Code session may be enough for some tasks.

• A full agentic workflow is justified only when the work requires it.

Anthropic’s subagent docs describe built-in and custom subagents, with Claude using a subagent’s description to decide when to delegate. That is important because the architect must define subagents clearly enough for delegation to be useful.

The key exam idea:

A subagent is not “more AI.” A subagent is separation of concerns.

Articles 31–39: MCP, External Context, and Enterprise Integration

The fourth block moved beyond the repo.

The main ideas:

• Enterprise context lives outside the codebase.

• Jira, Confluence, GitHub, SharePoint, databases, logs, cloud tools, and internal APIs all matter.

• MCP is the bridge between AI applications and external systems.

• MCP must be governed.

• Read-only access is not the same as write access.

• Tool access should be explicit, trusted, and auditable.

The official MCP docs describe MCP as an open-source standard for connecting AI applications to external systems, including data sources, tools, and workflows.

The key exam idea:

Use MCP when Claude needs controlled access to external context or tools. Do not use MCP just because it sounds advanced.

Articles 40–49: Skills, Hooks, Memory, SDK, and the Delivery Loop

The fifth block assembled the Claude Code control points.

The main ideas:

• Skills package repeatable expertise.

• Hooks automate enforcement.

• Memory carries durable repo context.

• Subagents divide specialized work.

• MCP connects enterprise systems.

• SDK workflows make agentic patterns programmable.

• Evidence turns AI work into reviewable engineering work.

Anthropic’s hooks docs describe lifecycle hook events and configuration for automating actions, and the hooks guide covers common use cases and advanced features such as async hooks and MCP tool hooks.

Anthropic’s skills docs describe skills as a way to extend Claude’s capabilities in Claude Code, including custom commands and bundled skills.

The Agent SDK gives developers the same tools, agent loop, and context management that power Claude Code, programmable in Python and TypeScript.

The key exam idea:

These features are not random. They are control points in an engineering operating model.

Articles 50–60: Governance, Security, Simplicity, and Exam Mindset

The final block focused on how architects should answer scenario questions.

The main ideas:

• Least privilege matters.

• Security is part of the architecture.

• MCP access must be trusted and controlled.

• Hooks, skills, and memory can carry governance into the workflow.

• Auditability preserves trust.

• Human approval is still required for high-risk decisions.

• Simplicity wins.

• Choose the smallest architecture that satisfies the intent and risk.

Anthropic’s Claude Code security docs specifically warn that MCP servers should come from providers you trust, that permissions can be configured for MCP servers, and that Anthropic does not security-audit or manage every MCP server. That reinforces the enterprise point: architects must treat external tool access as a security boundary.

The key exam idea:

Safe acceleration beats blind automation.

The Study Checklist

Before the exam, make sure you can explain these without notes.

Claude Code

Claude Code is best when work is repo-centered.

Use it for:

• Reading code

• Modifying files

• Running commands

• Writing tests

• Refactoring

• Debugging

• Explaining implementation

• Preparing PRs

• Working across multiple files

Study:

• Claude Code overview

• Common workflows

• Memory

• Hooks

• Subagents

• Skills

• Settings

• Security

• GitHub Actions

Good starting points:

• Claude Code Overview

• Common Workflows

• Claude Code Settings

• Claude Code GitHub Actions

Memory

Memory is durable project context.

Use memory when Claude needs to know:

• Repo purpose

• Setup commands

• Test commands

• Folder structure

• Architecture rules

• Coding standards

• Files to avoid

• Definition of done

Study:

• CLAUDE.md

• Auto memory

• Project instructions

• What belongs in memory versus intent

Primary link:

• How Claude remembers your project

Exam phrase:

Memory is context governance.

Subagents

Subagents are specialist roles.

Use them for:

• Security review

• Test review

• Architecture review

• Repo pattern inspection

• Evidence validation

• Release readiness

• Specialized domain checks

Study:

• Built-in subagents

• Custom subagents

• Description quality

• Tool access

• Delegation boundaries

Primary link:

• Create custom subagents

Exam phrase:

Subagents separate responsibility.

Hooks

Hooks automate enforcement.

Use them for:

• Formatting after edits

• Running tests

• Blocking unsafe commands

• Checking secrets

• Capturing evidence

• Validating intent files

• Producing PR summaries

Study:

• Hook events

• JSON input and output

• Exit codes

• Async hooks

• MCP tool hooks

Primary links:

• Hooks reference

• Automate actions with hooks

Exam phrase:

Hooks turn good habits into automation.

Skills

Skills package repeatable expertise.

Use them for:

• API review

• Test evidence generation

• Terraform inspection

• React component review

• Secure logging

• Release summaries

• Intent-to-evidence workflows

Study:

• Skill structure

• SKILL.md

• When Claude invokes a skill

• Team standards as reusable capability

Primary link:

• Extend Claude with skills

Exam phrase:

Skills convert team knowledge into reusable capability.

MCP

MCP connects Claude to external systems.

Use it when Claude needs:

• Jira context

• Confluence pages

• GitHub data

• Databases

• Internal APIs

• Observability tools

• Cloud tools

• External workflow actions

Study:

• MCP architecture

• MCP tools

• Resources

• Prompts

• Authorization

• Trusted servers

• Read/write boundaries

Primary links:

• MCP introduction

• MCP architecture overview

• MCP tools specification

• MCP authorization

• MCP Registry announcement

Exam phrase:

MCP is the enterprise context bridge, but it must be governed.

SDK and API

Use the API when you want Claude inside an application or service.

Use the SDK when you want Claude Code-like agentic workflows programmatically.

The Agent SDK is especially relevant when you need:

• File access

• Command execution

• Codebase search

• Hooks

• Subagents

• MCP

• Permissions

• Sessions

• Repeatable automation

Primary links:

• Agent SDK overview

• Agent SDK capabilities overview

• TypeScript Agent SDK repository

Exam phrase:

API is for model access. SDK is for programmable agentic workflow. Claude Code is for interactive repo work.

Quick “When to Use What” Table

Need

Best Choice

Why

Modify code in a repo

Claude Code

It understands files, commands, tests, and repo workflows

Add Claude to a custom app

Claude API

Direct model access from an application

Build repeatable agent workflows

Agent SDK

Programmatic Claude Code-style automation

Connect to Jira, Confluence, GitHub, databases, or tools

MCP

Standardized external context and tool access

Preserve repo instructions

Memory / CLAUDE.md

Durable project context

Package repeatable expertise

Skills

Reusable team capability

Delegate specialist review

Subagents

Separation of concerns

Enforce workflow behavior

Hooks

Automated checks and controls

Review PRs or automate GitHub workflow

Claude Code GitHub Actions

AI assistance in GitHub workflow

Handle production, secrets, customer data, or high-risk changes

Human approval plus controls

Accountability stays with people

The Exam-Day Answer Framework

When you see a scenario, do not rush.

Use this sequence:

1. Identify the goal.

   
   

   What is the team actually trying to accomplish?

2. Identify the context.

   
   

   Is this repo-local, enterprise-wide, app-integrated, or workflow automation?

3. Identify the risk.

   
   

   Is it documentation, UI, backend, infrastructure, security, data, or production?

4. Choose the simplest architecture.

   
   

   Do not use MCP, SDK, or subagents unless the scenario requires them.

5. Define boundaries.

   
   

   What can Claude read, write, run, or invoke?

6. Add governance.

   
   

   Use memory, hooks, skills, permissions, and human approval where needed.

7. Require evidence.

   
   

   Tests, logs, screenshots, reports, security scans, or PR summaries.

8. End with a decision.

   
   

   Ready, ready with caution, blocked, or needs human review.

That framework will handle most architecture scenarios.

Resource Pack: Official Docs

Start here first.

• Claude Code Overview

• Claude Code Common Workflows

• Claude Code Memory / CLAUDE.md

• Claude Code Subagents

• Claude Code Hooks Reference

• Claude Code Hooks Guide

• Claude Code Skills

• Claude Code Settings and Plugins

• Claude Code Security

• Claude Code Enterprise Deployment

• Claude Code GitHub Actions

• Agent SDK Overview

• MCP Introduction

• MCP Architecture Overview

• MCP Tools Specification

• MCP Authorization

Resource Pack: GitHub Repositories

Use these for hands-on inspection.

• Anthropic organization on GitHub — good place to track official Anthropic-managed repositories and examples.

• anthropics/claude-code — official Claude Code repository, described as an agentic coding tool that lives in the terminal, understands the codebase, and helps with routine tasks, explanations, and git workflows.

• anthropics/claude-agent-sdk-typescript — official TypeScript SDK repository for building agents with Claude Code capabilities.

• aws-samples/anthropic-on-aws — AWS examples and notebooks for using Anthropic on AWS.

Study these with a specific purpose.

Do not just browse them randomly.

Look for:

• How examples structure prompts

• How tools are configured

• How SDK sessions are started

• How permissions are handled

• How workflows are organized

• How code changes are validated

• How repo-level instructions are represented

Resource Pack: YouTube / Video Study

Use video after reading the docs. Video is good for flow, but the official docs are better for precision.

Good videos and channels to inspect:

• Anthropic YouTube channel — official Anthropic videos, including Claude and MCP-related content.

• MCP 201 from Code w/ Claude — useful for understanding MCP from an Anthropic event context.

• Claude Agent SDK workshop by Thariq Shihipar from Anthropic — useful for SDK workflow thinking.

• Mastering Claude Code in 30 minutes — useful practical walkthrough material.

• Claude Code guide covering MCP, skills, and related concepts — useful for a broad review pass.

Watch with a checklist:

• What problem is being solved?

• Is this Claude Code, API, SDK, MCP, or all of them?

• What is the control point?

• What permissions are implied?

• What evidence is produced?

• Could this be simplified?

That last question matters.

The exam will reward simplicity.

Resource Pack: Research and Deeper Reading

A few recent papers and studies are worth scanning if you want deeper context.

One 2026 paper analyzing Claude Code describes it as an agentic coding tool that can run shell commands, edit files, and call external services, and it frames much of the system around safety, permissioning, context management, extensibility, subagents, and session storage.

Another 2026 study of command-line AI coding agents at Microsoft reported that adopters merged roughly 24% more pull requests than they otherwise would have, while also warning that merged PRs are only a proxy for output, not necessarily delivered value. That is exactly why architects should measure outcomes, not just activity.

A 2026 paper on AI coding agents and documentation portals argues that agent access changes how documentation is consumed, compressing multi-page navigation into fewer requests and making traditional engagement metrics less reliable. That matters for teams building AI-readable engineering knowledge.

There is also a 2026 paper on using Claude Code to teach Claude Code, which reinforces the idea that structured curricula and hands-on workflows matter because developers otherwise rely on fragmented docs, tutorials, and trial-and-error.

Do not over-study research papers for the exam.

Use them to reinforce the bigger picture:

Agents are becoming real engineering actors, and architecture must adapt.

The Final Mental Model

Here is the simplest possible mental model.

Claude Code is the repo worker.

Memory is the project knowledge.

Skills are reusable expertise.

Subagents are specialist roles.

Hooks are automated enforcement.

MCP is external context and tools.

The API is direct model access.

The SDK is programmable agentic workflow.

Permissions are the boundaries.

Evidence is the proof.

Auditability is the trust trail.

Human approval is the safety valve.

Intent is the starting point.

Release decision is the finish line.

That is the system.

What to Study for the Next Two Weeks

Do not try to read everything randomly.

Use a three-pass approach.

Pass 1: Read for concepts

Read your 60 articles quickly.

Do not memorize.

Look for repeated ideas:

• Intent

• Context

• Simplicity

• Tool choice

• Governance

• Evidence

• Human decision points

Pass 2: Read the official docs

Focus on:

• Claude Code overview

• Memory

• Hooks

• Skills

• Subagents

• MCP

• Security

• SDK

• GitHub Actions

Take notes in your own words.

Pass 3: Practice scenario answers

Create fake exam scenarios.

For each one, answer:

• What is the goal?

• Which tool should be used?

• What permissions are needed?

• What should be automated?

• What needs human approval?

• What evidence proves success?

• What is the release decision?

That is how you prepare like an architect.

Final Exam-Day Reminders

Start with the goal, not the tool.

Choose the simplest architecture that works.

Use Claude Code for repo work.

Use the API for application-level model calls.

Use the SDK for programmable agentic workflows.

Use MCP for external systems and enterprise context.

Use memory for durable project guidance.

Use skills for repeatable expertise.

Use subagents for specialist delegation.

Use hooks for enforcement.

Use permissions for boundaries.

Use evidence for trust.

Use human approval for high-risk decisions.

Do not over-automate.

Do not over-architect.

Do not confuse output with value.

Do not confuse a passing build with proof.

Do not confuse agent autonomy with enterprise readiness.

The architect’s job is not to use more tools.

The architect’s job is to use the right tools, in the right places, with the right controls, to produce the right outcome.

That is the final lesson.

Sixty articles.

One field guide.

One operating model.

Intent drives. Context grounds. Evidence proves. Architects decide.

:::