Master the Claude Partner Network (CPN) Claude Certified Architect - Foundations (CCA-F) 5 day course

Readme.md

Claude Partner Network CCA-F (Claude Certified Architect - Foundations) 5 Day Course

To pass the certification, you must move past basic prompt engineering and master three production-level concepts: Tool Use & Latency Optimization, which involves architecting parallel tool calling, managing token overhead, handling intermediate tool results, and optimizing time-to-first-token (TTFT); the Model Context Protocol (MCP), an open-standard architecture that eliminates $N \times M$ custom integration silos by requiring you to build and secure its three core primitives of Tools (actions), Resources (data), and Prompts (templates); and Data Governance & Transport, which demands knowing when to deploy secure, local stdio transport versus scalable, remote SSE/Streamable HTTP transport, alongside implementing strict roots-based file access permission designs.

---

Here is your intensive 5-day roadmap to pass the proctored exam.

Day 1: Foundations & API Architecture

Focus: Deep-dive into core API interactions, prompt engineering at scale, and cost optimization.

Coursework: Complete the Claude 101 and the first half of Building with the Claude API modules.

Core Concepts to Master: * Prompt caching mechanics (to achieve up to 90% cost reduction on large contexts).

    System prompts vs. user prompts in enterprise orchestration.

    Token windows, tracking input/output costs, and managing rate limits under heavy production loads.

Day 2: Tool Use & The Claude Agent SDK

Focus: Transitioning from text generation to autonomous execution.

Coursework: Complete the Building with the Claude API (Tool Use sections) and review the Claude Agent SDK documentation.

Core Concepts to Master:

    The exact JSON structure for schema definition in tool calling.

    How the model handles multi-step tool execution loops.

    Mitigating hallucinations and handling structural or missing-data errors when Claude calls external APIs.

Day 3: Model Context Protocol (MCP)

Focus: Connecting Claude to secure enterprise data systems. This is heavily emphasized on the test.

Coursework: Complete Introduction to Model Context Protocol and Model Context Protocol: Advanced Topics.

Core Concepts to Master:

    The 3 primitives of MCP: Tools (actions), Resources (data read-only streams), and Prompts (pre-built templates).

    Building an MCP host vs. building an MCP server in Python.

    Transport layer security protocols for keeping sensitive internal data private when connected to Claude.

Day 4: Agentic Workflows with Claude Code

Focus: Terminal-based automation, CI/CD pipelines, and Tech Lead delegation patterns.

Coursework: Complete Claude Code 101 and Claude Code in Action.

Core Concepts to Master:

    Setting up context using the CLAUDE.md architecture.

    Knowing when to explicitly invoke /plan mode vs. executing code directly.

    Integrating Claude Code into GitHub Actions or standard CI/CD pipelines for automated code reviews.

    Managing cost budgets on long-running local terminal sessions using /compact.

Day 5: Multi-Agent Architectures & Practice Exam

Focus: Designing production-grade multi-agent networks and system validation.

Coursework: Review Introduction to Subagents and execute a small multi-step mock deployment using fetch or the Python SDK.

Core Concepts to Master:

    The "Best of N" generation pattern for algorithmic validation.

    Guardrails, orchestration, and monitoring system drift.

Exam Strategy: Take the mock evaluation quizzes on the Partner portal. The passing score is 720 out of 1000. The questions are entirely multiple-choice but feature real-world debugging scenarios where wrong syntax or improper RAG pipelines will penalize your score.

Action Checklist to Begin Right Now:

    Gain Portal Access: Ensure your employer or consulting firm has requested access to the Claude Partner Hub. (The certification exams are currently free for members of the Claude Partner Network).

    Spin up your Sandbox: Open up your local terminal and install Claude Code (npm i -g @anthropic-ai/claude-code) right away so you can test commands dynamically as you study.

---

Core Key Concepts

To become a Claude Certified Architect and pass the Foundations exam, you must master the architecture knowledge needed to design, build, and operate production systems using Claude.

Based on the exam preparation materials, here are the top 10 key concepts you need to learn.

1. API Statelessness and Context Management

Claude’s Messages API is entirely stateless, meaning the model has no internal memory of past interactions. Architects must design the application layer to explicitly store conversation history and re-transmit the full transcript (system prompt, prior turns, and tool results) in every request. You must also understand how token growth in these transcript payloads leads to cumulative increases in cost and latency over long sessions.

2. Structured Output Control

Production systems should prioritize schema-backed output control over simple prompt engineering. You need to know when to use:

• JSON Structured Outputs: For final, terminal responses validated against a JSON Schema.
• Tool Use: For intermediate extraction steps or agentic actions.
• tool_choice: Understanding the difference between auto (optional tool use), any (guaranteed tool use from a set), and specific named tools.

3. Tool Interface Design Patterns

A vague tool interface often results in model errors that look like reasoning failures. Key patterns include:

• Lookup-then-act: Implementing a non-destructive search (e.g., search_servers) to return unique IDs before calling a destructive tool (e.g., delete_server).
• Specialized vs. Monolithic Tools: Splitting complex tools with interdependent parameters into specialized interfaces to simplify model selection and prevent invalid inputs.

4. Advanced Error Handling

Architects must distinguish between different failure tiers to guide agent behavior:

• Transient errors: Network blips or timeouts should be retried internally within the tool logic.
• Permanent validation errors: These must be sent back to the model so it can fix its parameters.
• Uncertain side effects: Write timeouts (like a mid-request payment failure) must be flagged as uncertain and never automatically retried without an idempotency check to avoid duplicate actions.

5. Model Context Protocol (MCP)

MCP is the open standard for connecting AI applications to external systems. You must understand its three main components:

• Tools: Model-controlled actions.
• Resources: Application-controlled context like database schemas or file catalogs.
• Prompts: Reusable workflow templates.

6. Agentic Patterns and Task Decomposition

Understanding how to structure the model's autonomy is critical. Key patterns include:

• Prompt Chaining: For fixed workflows with known steps.
• Orchestrator-Workers: Where a coordinator agent chooses and delegates to specialized subagents.
• Parallel Subagents: Partitioning a large task (like auditing 50 repositories) into independent pieces to run concurrently, reducing total elapsed time.

7. System Prompt Engineering

The system prompt defines the agent's role, tone, and constraints. Architects should use XML-style tags to improve salience and organization. It is important to remember that attention to the system prompt weakens as conversations grow, requiring structural reinforcements like user-role reminders at natural breakpoints.

8. Reliable Structured Data Extraction

To reduce "fabrication" (hallucination) in extraction pipelines, schemas should use optional or nullable fields rather than forcing the model to invent values when information is missing from the source. Additionally, implementing a validation-error feedback loop (re-sending the source document alongside specific validation errors) is more effective than blind retries.

9. Claude Code and SDK Workflows

Mastery of the Claude Agent SDK and its built-in tools is required, specifically:

• Plan Mode: A workflow gate that allows the assistant to explore and propose changes for human review before execution.
• Hooks: Using PreToolUse hooks for hard enforcement of security policies, such as blocking destructive commands or edits to protected files.
• Memory Systems: Differentiating between CLAUDE.md (project-wide soft guidance) and Auto memory (debugging insights the model learns over time).

10. Batch Processing and SLA Management

The Message Batches API offers a roughly 50% discount for high-volume asynchronous work. Architects must be able to calculate the necessary submission cadence to meet Service Level Agreements (SLAs), given that batches have a worst-case completion window of 24 hours.

CLAUDE.md

NOTE: Add this to your CLAUDE.md

Project Guidelines

Agent Behavior & Constraints

• CRITICAL: Before executing any code, file modifications, or architectural decisions, you MUST validate your current task against the routing directives defined in .claude/system_prompt.
• You are operating as a Meta-Prompt Route Orchestrator.
• If a task falls into Analyzing, Writing, Reviewing, or Architecting, you must halt autonomous execution and ask the user for the required file context or diffs specified in the Interception Protocol.

INSTRUCTIONS-FOR-FDE.md

As we scale our operations and embed deeper into our clients' custom environments, maximizing the value of our Forward-Deployed Engineers (FDEs) is critical. Because our FDEs operate directly within unique client codebases, internal APIs, and bespoke architectural guardrails, we need a frictionless way to standardize our tribal knowledge and architecture patterns across the engineering organization.

To achieve this, we are bridging the gap between our local Obsidian engineering vaults—where many of our leads already curate deep operational context—and our corporate LLM environment.

In production, we are implementing this using the Model Context Protocol (MCP) to securely expose local Markdown knowledge bases directly to Claude's agentic workspace tools.

Here is how we are breaking this down structurally for the team:

1. The Local FDE Workflow (Individual Node Integration)

For individual engineers who want Claude Code running locally to seamlessly read project-specific Obsidian notes alongside active repos, we are leveraging the official MCP Filesystem Server.

By appending an absolute file-system transport hook directly to the local Claude configuration, the agent can query Markdown files via standard stdio transport:

{
  "mcpServers": {
    "engineering-vault": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/username/Documents/Obsidian/ClientContext"]
    }
  }
}

---

The following is preferred ideal state of how we can follow the same exact prompts and techniques in delivering our solutions across the team.

The Ideal Architecture: Link Obsidian to the Corporate LLM

Instead of manually uploading files or copying and pasting text, you can turn your Obsidian vault folder into a secure, live data stream that Claude Code can query locally or host remotely for your team.

Here are the two ways to execute this strategy based on your deployment needs:

Method 1: Local FDE Workflow (Individual Sharing via Claude Code)

If you want Claude Code running on your local machine to automatically read your Obsidian notes (like system prompts, architecture choices, or debugging logs) alongside your company codebase, you use the official MCP Filesystem Server.

1. Install the Filesystem MCP Server: Configure Claude Code to look at your Obsidian Vault directory by adding a filesystem transport hook to your local configuration.
2. Configure the Path: Point the server directly to your Obsidian path:

{
  "mcpServers": {
    "obsidian-vault": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourusername/Documents/ObsidianVault"]
    }
  }
}

3. Agentic Execution: Now, when you boot up Claude Code in the company codebase, you can issue commands that span both directories:

"Read the architecture rules from @obsidian-vault/PROMPT_CREATOR.md and use them to refactor the corporate registration repository."

---

Next Level Shared Zettelkasten (Across the Team)

If you want your entire engineering team to access the same centralized rules, templates, and code design patterns you've curated in Obsidian, you must transition from a local stdio transport layer to a remote SSE (Server-Sent Events) HTTP transport layer.

1. Git-Sync Your Obsidian Folder: Treat your specific corporate Obsidian folder as a standard Git repository. Have your engineering team clone it locally or back it up to an internal company repository (e.g., GitLab or GitHub Enterprise).
2. Deploy an Enterprise MCP Bridge: Run a centralized MCP server inside the company's secure cloud perimeter (AWS/GCP/Cloudflare) that hosts these files as read-only Resources.
3. Connect the Company LLM: Configure the company’s internal Claude Team deployment or custom API orchestrator to connect to that remote MCP endpoint.

---

Best Practices for Forward-Deployed Data Governance

When bridging personal knowledge bases (Obsidian) with enterprise source code using AI agents, you must implement strict roots-based file permission access designs to prevent data leaks:

• Strict Separation of Concerns: Keep a dedicated Client-Company-X/ folder inside your Obsidian vault. Never let the filesystem MCP server see your entire root vault—only point it at that specific client's directory.
• Exclude Sensitive Data (.gitignore): Ensure any local system configurations, private API tokens, or hardcoded credentials inside your .claude/ or .obsidian/ folders are explicitly ignored so they are never leaked to shared corporate repositories.
• Use Relative Resource Paths: When writing markdown files in Obsidian that you intend to share with the company LLM, use standard relative linking (e.g., [[CLAUDE.md]]). Claude’s agentic context tools will easily resolve these paths when parsing the vault files.

OPTIMIZING_CLAUDE_COSTS.md

Optimizing costs and token usage when working with the Claude API requires a strategic approach to architecture and context management. Because Claude is stateless, it has no memory of past interactions; every time you send a message, you must include all previous relevant context for the model to understand the conversation. This means that as a conversation grows, so does the "backpack" of reminders you send, which can quickly increase costs if not managed carefully.

The sources suggest the following best strategies for cost and token optimization:

1. Minimize Unnecessary Context

The most direct way to control costs is to minimize the amount of context sent in each request. Since more context generally leads to higher costs and increased latency, you should avoid sending full transcripts if they aren't required. Instead, only include the specific information necessary for Claude to complete the current task.

2. Use Retrieval-Augmented Generation (RAG)

Rather than feeding Claude a giant document or an entire conversation history, use Retrieval-Augmented Generation (RAG). This strategy involves searching through a large dataset and providing Claude with only the relevant excerpts needed for the query, rather than the full transcript. This significantly reduces input tokens while maintaining accuracy.

3. Implement Summarization Strategies

For long-running conversations, the sources recommend using summarization strategies. Instead of re-sending every message from a long chat history, your application can summarize the earlier parts of the conversation and send only the summary alongside the most recent messages. This keeps the model "up to speed" while using fewer tokens than a full history.

4. Leverage Structured Outputs

Claude often provides "chatty," free-form text by default. By using structured outputs (such as JSON) and schema-based responses, you can force the model to "color inside the lines" and provide only the specific data you need. This reduces tokens wasted on unnecessary conversational filler and makes responses more predictable and reliable.

5. Efficient Model Selection and Batching

• Select Appropriate Models: Not every task requires the most powerful (and expensive) model; choosing the right model for the specific complexity of your task can save significant costs.
• Batch and Reuse Processing: Where possible, batch requests and reuse processing results to avoid redundant computations.

6. Refine Prompt Engineering

Better prompt engineering results in more predictable and reliable responses. By providing clear instructions and constraints, you reduce the likelihood of "hallucinations" or incorrect responses that would require additional requests (and more tokens) to correct. Production systems should use standardized prompt templates and repeatable patterns rather than one-off prompts to maintain efficiency at scale.

setup.sh

#!/bin/bash

mkdir -p .claude && touch .claude/system_prompt

system_prompt

You are a Claude Certified Architect (CCA/CFA-P) operating as an embedded Forward Deployed Engineer (FDE). Your job is to act as a Meta-Prompt Route Orchestrator. Whenever I start a prompt or use the command `/use-prompt-creator`, you must intercept my request, categorize it into one of four specific operational personas, map it to the correct production tool/hook, check for architectural context files (`CLAUDE.md`, `AGENTS.md`), and ask me for the exact file paths or diffs needed before generating any code.

Here is your routing matrix and execution guide:

### 1. OPERATIONAL PERSONAS & TOOL MAPPING

* **Task: Analyzing Code**
    * *Persona:* Senior Code Auditor
    * *Required Hook:* Local `/plan` mode token analysis and deep ast-scanning.
    * *Action:* Immediately ask me: "Which file(s) or directories do you want to analyze?" Do not analyze until the files are provided.

* **Task: Writing Code**
    * *Persona:* Senior Full-Stack Engineer (PHP/Symfony/Vanilla JS/Cloud Native)
    * *Required Hook:* Local execution mode, checking against project-wide constraints in `CLAUDE.md`.
    * *Action:* Check if `CLAUDE.md` exists or ask me for the technical specifications (e.g., "Are we adhering to standard Symfony templates without jQuery? Provide target file path").

* **Task: Pull Request / Code Reviews**
    * *Persona:* Tech Lead / Gatekeeper
    * *Required Hook:* Multi-file line-by-line file diffing tool (`git diff` simulation).
    * *Action:* Immediately ask me to supply the `file.diff` or pull request patch. You must state that you are cross-referencing the changes against the orchestration roles defined in your `AGENTS.md` file.

* **Task: Senior Web & Cloud Architecting**
    * *Persona:* Principal Cloud & Systems Architect (S3, Cloudflare R2, Multi-Agent Systems)
    * *Required Hook:* MCP (Model Context Protocol) Infrastructure Design & Transport Layer Optimization.
    * *Action:* Focus on decoupling, data governance, performance metrics (TTFT), and transport layer choices (stdio vs. SSE).

### 2. THE INTERCEPTION PROTOCOL
When I invoke `/use-prompt-creator [task/problem description]` or present a scenario fitting the categories above, you must NOT write the final solution immediately. Instead, reply strictly in this format:

"**[CCA Router Active]**
* **Identified Persona:** [Senior Code Auditor / Tech Lead / etc.]
* **Target Tool/Context Layer:** [e.g., Diffing tool / AGENTS.md constraints / CLAUDE.md rules]
* **Architectural Focus:** [e.g., Latency Optimization / Decoupled Upload Patterns]

To build the perfect prompt and execute this, please provide:
1. [Specific file paths, file.diff, or architectural parameters needed]"

Once I give you those missing pieces, you will generate the highly optimized, production-level prompt or solution. Do you understand your routing directives?