Claude Certified Architect – Foundations (CCA-F)

Agent loops, planning vs. acting, multi-step orchestration, when to use an agent vs. a single call, failure/recovery design, human-in-the-loop.

1. Decide between a workflow (fixed orchestration) and an agent (model-directed loop) for a given problem, defaulting to the simplest thing that works.
2. Select the right workflow pattern (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) for a task's shape.
3. Design agent loops with clear stopping conditions, budgets, and failure/recovery paths.
4. Place human-in-the-loop checkpoints where actions are irreversible or high-blast-radius.
5. Diagnose why an agentic system misbehaves (context loss, tool ambiguity, unbounded loops) and pick the structural fix.
6. Design multi-agent orchestration (subagents, delegation) and know when it's overkill.

Claude Code settings, hooks, slash commands, subagents, permissions, CLAUDE.md memory, and MCP wiring.

1. Configure settings.json correctly across user/project/local scopes, including permission allow/deny rules.
2. Choose and implement the right hook (PreToolUse, PostToolUse, etc.) to enforce a policy deterministically.
3. Author CLAUDE.md memory files that give durable project instructions without bloating context.
4. Create custom slash commands and know when a slash command beats a CLAUDE.md instruction.
5. Define subagents with scoped tools/permissions for delegated tasks.
6. Wire MCP servers into Claude Code (project vs user scope) and control which tools are exposed.

Structured prompting, XML tags, examples/multishot, chain-of-thought, output control, prefilling, evaluation.

1. Structure prompts with XML tags to separate instructions, context, and examples unambiguously.
2. Use multishot examples to pin down format and edge-case behavior — and know when examples beat instructions.
3. Apply chain-of-thought / extended thinking appropriately, and know when it adds latency without accuracy.
4. Control output format (prefilling, stop sequences, forced JSON) deterministically rather than by asking nicely.
5. Design evaluation for prompts (success criteria, empirical test cases) before tuning them.
6. Choose system-prompt roles and put the right content in system vs user turns.

Tool schemas, tool boundaries, the MCP server/client model, tool vs. in-prompt tradeoffs, error handling.

1. Write tool definitions (name, description, JSON schema) that a model reliably uses correctly.
2. Draw tool boundaries: one well-scoped tool vs many granular ones; avoid ambiguous overlap between tools.
3. Explain the MCP architecture (host/client/server; tools, resources, prompts) and its transports (stdio, HTTP).
4. Decide between an MCP server, a bespoke tool, or in-prompt context for a given integration.
5. Design tool error handling: return actionable, model-readable errors; make destructive operations explicit and confirmable.
6. Apply security thinking to tools: least privilege, input validation, treating tool output as untrusted.

Context windows, what to include/exclude, retrieval vs. stuffing, long-conversation strategies, prompt caching, cost/latency tradeoffs.

1. Budget a context window: what belongs in system prompt, tools, retrieved context, and history.
2. Choose retrieval vs. context-stuffing based on corpus size, change rate, and cost.
3. Apply long-conversation strategies: summarization/compaction, external memory, subagent isolation.
4. Use prompt caching correctly (stable prefix first, cache breakpoints) and know what invalidates it.
5. Reason about cost/latency: input vs output tokens, caching economics, model right-sizing.
6. Diagnose context-rot symptoms (ignored instructions, degraded recall) and fix them structurally.