DEV Community: Jeremy King

How I Would Prepare to Pass the Anthropic CCA-F Exam

Jeremy King — Wed, 22 Jul 2026 06:04:11 +0000

The Anthropic CCA-F exam is not the kind of certification you can brute-force by memorizing API parameters.

CCA-F, or Claude Certified Architect - Foundations, is much closer to an architecture judgment exam. It asks whether you can choose the right design when a Claude system has real production constraints: context limits, unreliable tools, permission boundaries, human review requirements, multi-agent coordination, latency budgets, and failure recovery.

That changes how you should study.

If your plan is only to read docs and collect definitions, you will probably feel prepared until the first scenario question gives you two answers that both look reasonable. The exam is really about knowing which option survives the constraints in the prompt.

Here is the preparation strategy I would use.

1. Start with the exam shape, not the docs

Before studying deeply, understand what the exam is trying to measure.

The public CCA-F preparation material consistently points to five major areas:

Agentic architecture and orchestration
Tool design and MCP
Claude Code configuration and workflows
Prompt engineering and structured output
Context management and reliability

Do not study these as isolated topics. The exam is scenario-based, so the real skill is tradeoff selection.

For example, do not only ask:

What is MCP?

Ask:

When should I expose something through an MCP server instead of baking it into application logic?

Do not only ask:

What is a subagent?

Ask:

When does delegation reduce complexity, and when does it create coordination overhead?

That shift matters.

2. Build one small Claude system before over-studying

You do not need a huge production application, but you should build something that forces the core ideas to become practical.

A good starter project could be:

A support-ticket triage agent
A code-review assistant using Claude Code
A document extraction workflow with JSON schema validation
A research assistant with a search tool and a summarization step
A small MCP server exposing one real backend action

The goal is not to create a polished product. The goal is to experience the failure modes the exam cares about:

The model asks for missing context.
A tool returns partial or malformed data.
The prompt is too vague.
A long conversation loses important details.
A user request needs escalation instead of automation.
A workflow needs validation before output is trusted.

Once you have felt those problems, the exam scenarios become much easier to reason about.

3. Study each domain as a set of decisions

I would organize notes around decisions, not definitions.

For agentic architecture, focus on:

When to use a single agent vs. multiple agents
How to decompose tasks
How to preserve state across steps
How to recover from tool failures
Where human approval belongs

For tool design and MCP, focus on:

Tool input schemas
Clear error responses
Permission boundaries
Tool granularity
Whether the tool should return raw data or normalized data

For Claude Code workflows, focus on:

CLAUDE.md as project context
Plan mode vs. direct execution
Custom commands and skills
MCP integrations
CI/CD and review workflows

For prompt engineering, focus on:

Explicit success criteria
Structured outputs
Few-shot examples
Validation loops
Guarding against ambiguous instructions

For context and reliability, focus on:

Context window management
Summaries and state handoff
Provenance
Escalation paths
Testing and evaluation

This style of study maps better to scenario questions than flashcard-only memorization.

4. Use Revizo for practice, but do not outsource your judgment

I used the Revizo app as part of my practice routine because I wanted repeated exposure to exam-style questions in short sessions.

That helped in three ways.

First, it made practice easier to fit into the day. I could answer a small set of questions between deeper study blocks instead of waiting for a perfect two-hour slot.

Second, it exposed weak spots faster than rereading notes. When I missed a question, I wrote down the exact reason: did I miss a constraint, misunderstand a domain concept, or choose an answer that was generally good but wrong for the scenario?

Third, it helped me build pacing. Scenario questions are slower than trivia questions. Practicing under light time pressure made me better at identifying the deciding phrase in the question.

But I would not treat any practice app as the source of truth. Use Revizo to find gaps, then go back to Anthropic's official material and your own hands-on project to close those gaps.

The pattern that worked best for me was:

Do a Revizo practice set.
Review every missed or guessed question.
Convert the mistake into a rule.
Validate that rule against docs or real code.
Re-test the same topic later.

That last step is important. If you only review immediately after missing a question, you are testing short-term recognition, not durable understanding.

5. Create a "constraint checklist"

Most hard CCA-F questions become easier when you look for the constraint that makes one answer better than another.

When reading a scenario, I would underline constraints like:

The system must be auditable.
The workflow runs without a human in the loop.
The user data is sensitive.
The agent is operating across multiple repositories.
Latency matters.
Tool calls are expensive.
Outputs must match a strict schema.
The context is too large to fit in one prompt.
The environment is stateless.
A junior developer must maintain the workflow.

Then I would ask:

Which answer respects the constraint most directly?

This prevents a common mistake: choosing the most powerful architecture instead of the most appropriate one.

6. Practice explaining why the wrong answers are wrong

For each practice question, do not stop at "the correct answer is B."

Write one sentence for each wrong answer:

A is too brittle because it assumes the tool always succeeds.
C leaks too much context into a subagent.
D skips validation even though the output feeds a downstream system.

This is where the learning happens. The exam often tests distinctions between plausible options. If you can explain why the tempting answer fails, you are much closer to exam readiness.

7. Take at least one full timed mock

Short practice is useful, but it does not replace a full-length simulation.

A full mock exam tests different skills:

Can you maintain focus across many scenario questions?
Can you move on when a question is taking too long?
Can you flag uncertain questions without losing your rhythm?
Can you avoid changing correct answers during panic review?

After the mock, sort mistakes by domain. If most misses are concentrated in one area, do not keep taking random mocks. Fix that domain first.

8. Final-week plan

In the last week, I would not try to learn everything from scratch.

I would use this schedule:

Day 1: Review exam domains and collect weak areas.
Day 2: Deep dive on agentic architecture and orchestration.
Day 3: Deep dive on tool design, MCP, and error handling.
Day 4: Deep dive on Claude Code workflows.
Day 5: Deep dive on prompting, structured outputs, and validation.
Day 6: Full timed mock plus review.
Day 7: Light review only. No heavy cramming.

The final day should be about clarity, not volume.

9. What I would avoid

I would avoid:

Memorizing large code blocks.
Ignoring hands-on practice.
Treating practice questions as dumps.
Studying every domain equally if one is clearly weaker.
Over-engineering every scenario.
Forgetting that "human review" is often the right architectural choice.

The exam rewards practical architectural judgment. Sometimes the best answer is not more automation. Sometimes it is clearer boundaries, better validation, or a safer escalation path.

10. My core advice

To pass CCA-F, study like an architect:

Build a small Claude workflow.
Learn the five domains.
Practice scenario questions.
Use Revizo to expose weak spots and improve pacing.
Always identify the binding constraint.
Explain why wrong answers fail.

That is the difference between knowing Claude features and being ready to design with Claude in production.

Before booking the exam, check the latest official Anthropic exam guide and certification portal details. Exam logistics can change, but the preparation principle is stable: practice making the right architectural decision under constraints.

References:

Anthropic announcement of Claude Certified Architect - Foundations: https://www.anthropic.com/news/claude-partner-network
Anthropic Claude Code Foundations webinar: https://www.anthropic.com/webinars/claude-code-foundations
CCA-F exam guide and domain overview: https://www.anthropiccertifications.com/exam-guide
Revizo app listing: https://apps.apple.com/sg/app/revizo/id6761345868

How I Cleared Microsoft AI-103 in Just One Week

Jeremy King — Mon, 22 Jun 2026 09:35:10 +0000

When I first booked my Microsoft AI-103 exam, I honestly wasn't sure if one week would be enough.

AI-103 (Designing and Implementing a Microsoft Azure AI Solution) covers a wide range of Azure AI services, from Azure AI Vision and Language to Azure OpenAI Service, AI Search, and responsible AI practices. While I had some experience working with Azure and AI concepts, I had never studied specifically for this certification.

With only seven days available before exam day, I decided to focus on high-impact learning rather than trying to consume every resource I could find.

Here's exactly what I did.

Day 1: Understand the Exam Objectives

The first thing I did was review the official Microsoft skills outline.

This helped me identify the major domains covered in the exam:

Azure AI Vision
Azure AI Language
Azure AI Speech
Azure AI Search
Azure OpenAI Service
Knowledge Mining
Responsible AI
Solution Design and Integration

Instead of immediately jumping into practice questions, I wanted to understand what Microsoft expected candidates to know.

This prevented me from wasting time studying topics that were unlikely to appear on the exam.

Days 2-3: Microsoft Learn

Most of my preparation started with Microsoft Learn.

The learning paths are free, well-structured, and closely aligned with the exam objectives.

I focused on:

Azure AI Services
Azure OpenAI Service
AI Search
Language Understanding
Computer Vision
Speech Services

One thing I noticed is that AI-103 isn't purely theoretical.

Microsoft expects candidates to understand how services are configured, integrated, secured, and monitored in real-world solutions.

While reading, I took notes on:

Service capabilities
Authentication methods
Pricing considerations
Deployment options
Common use cases

Days 4-5: Hands-On Practice

Reading documentation is important, but AI-103 contains many scenario-based questions.

To reinforce what I learned, I spent time reviewing sample implementations and practicing with Azure services whenever possible.

I focused on understanding:

When to use Azure AI Search versus Azure OpenAI
How Cognitive Services are secured
Data ingestion workflows
Responsible AI requirements
Monitoring and troubleshooting

This was the stage where concepts started connecting together.

Day 6: Practice Questions and Weak Areas

By Day 6, I felt comfortable with most of the content, but I still had gaps.

Practice questions helped me identify areas that needed more attention.

I used a combination of study materials, practice questions, and mobile review tools to test my understanding of key concepts.

For short study sessions during breaks, I occasionally used Revizo on my phone. I found it useful for quick knowledge checks and reviewing concepts when I wasn't sitting at my desk. Most of my learning still came from Microsoft Learn and hands-on review, but having a mobile option helped me make use of small pockets of time throughout the day.

Rather than focusing on scores, I paid close attention to explanations behind incorrect answers.

This turned out to be one of the most effective parts of my preparation.

Day 7: Final Review

The day before the exam, I stopped trying to learn new topics.

Instead, I reviewed:

My notes
Microsoft Learn summaries
Frequently missed concepts
Service limitations and capabilities

I also reviewed architecture scenarios involving:

Azure AI Search
Azure OpenAI Service
Language Services
Vision Services

The goal was reinforcement, not cramming.

Exam Day Experience

The actual exam felt fair but challenging.

Many questions were scenario-based and required understanding how multiple Azure AI services work together.

A few lessons stood out:

Read every requirement carefully.
Eliminate technically correct but suboptimal answers.
Pay attention to security, scalability, and cost considerations.
Understand the differences between similar services.

I found that practical understanding mattered more than memorization.

Resources I Used

These were the resources that contributed the most to my preparation:

Resource	Purpose
Microsoft Learn	Primary learning resource
Azure Documentation	Service-specific details
Hands-on Azure Practice	Understanding real-world implementation
Practice Questions	Identifying weak areas
Revizo (iOS)	Quick mobile review sessions during downtime

If I had to choose only one resource, it would be Microsoft Learn. The content is directly aligned with Microsoft's expectations and provides an excellent foundation for the exam.

Final Thoughts

Can someone pass AI-103 in a week?

I think it's possible if you already have some familiarity with Azure and can dedicate focused study time each day.

The key isn't finding a shortcut. It's concentrating on the exam objectives, understanding how Azure AI services fit together, and spending time reviewing your weak areas.

For me, one focused week was enough.

If you're preparing for AI-103, my advice is simple: start with Microsoft Learn, reinforce concepts through practice, and focus on understanding the "why" behind each service rather than memorizing facts.

Good luck with your exam preparation!

OpenClaw Basic Configuration: A Practical Starter Guide

Jeremy King — Sat, 20 Jun 2026 22:57:10 +0000

OpenClaw is easiest to understand if you treat it as a local-first control plane for an AI assistant. The model is only one part of the system. The real behavior comes from the gateway, the channels you expose, the tools you allow, the workspace you give it, and the safety boundaries around all of that.

This is a practical pass through the basic configuration I would check before calling an OpenClaw setup "ready enough to use."

1. Start with onboarding unless you have a reason not to

For a new install, the recommended path is still:

openclaw onboard --install-daemon

The onboarding flow handles the boring but important parts: choosing a model provider, storing auth, configuring the gateway, and getting a first usable session running. After that, you can inspect and refine the generated config instead of writing everything from scratch.

That is the right order. Let the tool create a valid baseline, then edit deliberately.

2. Know where the config lives

OpenClaw reads an optional JSON5 config from:

~/.openclaw/openclaw.json

You can point OpenClaw somewhere else with:

OPENCLAW_CONFIG_PATH=/path/to/openclaw.json

The important detail: OpenClaw validates config strictly. Unknown keys, wrong types, or invalid values can stop the gateway from starting. That sounds fussy, but it is a useful guardrail for an agent that may be connected to real accounts and real tools.

A tiny config might look like this:

{
  agents: {
    defaults: {
      workspace: "~/.openclaw/workspace"
    }
  },
  channels: {
    telegram: {
      enabled: true,
      dmPolicy: "pairing"
    }
  }
}

3. Use the CLI for small config edits

For one-off changes, prefer the config CLI over opening the file manually:

openclaw config get agents.defaults.workspace
openclaw config set agents.defaults.heartbeat.every "2h"
openclaw config unset plugins.entries.brave.config.webSearch.apiKey

For larger edits, direct editing is fine, but validate immediately:

openclaw config validate
openclaw doctor

If the gateway refuses to start after a config change, openclaw doctor is the first command I would run.

4. Pick a primary model and define fallbacks

Model configuration is usually under agents.defaults.model.

{
  agents: {
    defaults: {
      model: {
        primary: "anthropic/claude-sonnet-4-6",
        fallbacks: ["openai/gpt-5.4"]
      },
      models: {
        "anthropic/claude-sonnet-4-6": { alias: "Sonnet" },
        "openai/gpt-5.4": { alias: "GPT" }
      }
    }
  }
}

The convention is provider/model. If you define agents.defaults.models, that list becomes an allowlist for model selection. That is useful in team or multi-agent setups, but it can surprise you later when /model some-new-model fails because the model is not on the allowlist.

My rule of thumb:

Use a strong primary model for tool-enabled agents.
Add one or two fallbacks for reliability.
Avoid weak models for agents that read untrusted messages or operate real tools.

5. Lock down who can message the bot

This is the configuration area I would not skip.

Each channel has its own section, such as:

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "${TELEGRAM_BOT_TOKEN}",
      dmPolicy: "pairing",
      allowFrom: []
    }
  }
}

The common DM policies are:

pairing: unknown senders get a pairing code before they can interact.
allowlist: only approved senders can talk to the bot.
open: anyone can message it, and this should be rare.
disabled: DMs are ignored.

For a personal assistant, pairing is a sane default. For a public or team-facing channel, be much more explicit. The bot is not just chat UI; it may have tools behind it.

6. Treat sessions as part of privacy

Session configuration controls how conversation state is shared or isolated.

{
  session: {
    dmScope: "per-channel-peer",
    threadBindings: {
      enabled: true,
      idleHours: 24,
      maxAgeHours: 0
    },
    reset: {
      mode: "daily",
      atHour: 4,
      idleMinutes: 120
    }
  }
}

For single-user local experiments, a broad shared session can be convenient. For anything involving multiple people, channels, or accounts, isolate more aggressively. per-channel-peer is a good starting point because it avoids one person's context bleeding into another person's conversation.

7. Enable sandboxing before the agent meets messy inputs

OpenClaw can run tools with significant host access. That is powerful, and also exactly why sandboxing matters.

A basic sandbox posture:

{
  agents: {
    defaults: {
      sandbox: {
        mode: "non-main",
        scope: "agent"
      }
    }
  }
}

The practical interpretation:

off: no sandboxing.
non-main: keep the trusted main session direct, sandbox other sessions.
all: sandbox everything.

If you are connecting group chats, webhooks, public channels, or feeds that may contain prompt injection, prefer stricter isolation. The more untrusted the input, the smaller the tool surface should be.

8. Keep secrets out of plain config when possible

OpenClaw reads environment variables from the parent process, a local .env, and ~/.openclaw/.env. You can reference env vars in config strings:

{
  gateway: {
    auth: {
      token: "${OPENCLAW_GATEWAY_TOKEN}"
    }
  },
  channels: {
    telegram: {
      botToken: "${TELEGRAM_BOT_TOKEN}"
    }
  }
}

That is better than hardcoding tokens into a config file you might sync, back up, or paste into a ticket. For more advanced setups, OpenClaw also supports secret references through env, file, and exec-backed providers.

9. Use hot reload, but know its limits

The gateway watches ~/.openclaw/openclaw.json and can hot-apply many changes. Agent, model, channel, tool, session, cron, and logging changes are generally designed to apply without a full manual restart.

Gateway server settings are different. Port, bind address, TLS, auth, and similar gateway-level changes may require restart behavior.

So the habit is:

openclaw config validate
openclaw gateway status
openclaw doctor

If you changed a networking or auth-related setting, expect a restart to be involved.

10. A starter checklist

Before using OpenClaw for anything real, I would check:

openclaw onboard --install-daemon has completed successfully.
openclaw gateway status reports the gateway is running.
The primary model and fallbacks are configured.
Each channel has a deliberate dmPolicy.
Group chats require mention unless you truly want always-on behavior.
Multi-user setups use isolated session scope.
Sandbox mode is enabled for non-main or untrusted sessions.
Secrets come from env vars or secret refs, not pasted tokens.
openclaw doctor is clean.

The theme is simple: configure OpenClaw like an assistant with hands, not like a chatbot with text. Once it can touch tools, accounts, files, or other people, basic configuration becomes part of your safety model.

References:

OpenClaw GitHub README: https://github.com/openclaw/openclaw
Getting started: https://docs.openclaw.ai/start/getting-started
Gateway configuration: https://docs.openclaw.ai/gateway/configuration
Models CLI: https://docs.openclaw.ai/concepts/models

How I Passed AWS SAP-C02 in Just 3 Days

Jeremy King — Sat, 20 Jun 2026 22:46:24 +0000

When I tell people I passed the AWS Certified Solutions Architect – Professional (SAP-C02) exam after only three days of preparation, the first reaction is usually:

"There's no way you learned SAP-C02 in three days."

And they would be right.

I didn't start from zero.

I already had several years of hands-on AWS experience and had previously passed SAA-C03. What I needed wasn't months of learning AWS services—it was three days of focused exam preparation to bridge the gap between real-world experience and AWS's exam style.

This article explains exactly what I used and what worked for me.

Day 0: Understanding What SAP-C02 Really Tests

One mistake I see many candidates make is treating SAP-C02 like a harder version of SAA.

It's not.

The exam is heavily focused on:

Multi-account architectures
AWS Organizations
Hybrid connectivity
Migration strategies
Disaster recovery
Cost optimization at scale
Complex networking scenarios
Security and governance

The questions are long.

Very long.

In many cases, the challenge isn't knowing the service. It's identifying the best architectural trade-off among several technically correct answers.

After reading through multiple Reddit success stories, one common theme stood out:

SAP-C02 is as much a reading-comprehension and architecture exam as it is an AWS knowledge exam.

I quickly realized that practice questions would be the key.

Day 1: Focused Theory Review

Instead of watching a 50+ hour course from start to finish, I reviewed only the topics where I felt weak.

The resources I used were:

AWS Documentation

I spent several hours reviewing:

AWS Organizations
Control Tower
Transit Gateway
Direct Connect
Site-to-Site VPN
Route 53 routing policies
Disaster Recovery patterns
Migration services

The AWS documentation remains the most reliable source when you're unsure about service limitations or implementation details.

Stephane Maarek's SAP-C02 Course

I didn't watch the entire course.

Instead, I jumped directly to:

Hybrid networking
Security
Organizations
Migration
Cost optimization

Many SAP-C02 candidates on Reddit consistently recommend Stephane's course as a strong foundation resource, especially when paired with practice exams.

Day 2: Practice Questions, Practice Questions, Practice Questions

This was easily the most important day.

If I had to credit one factor for passing, it would be practice exams.

Tutorials Dojo

I completed multiple timed and review-mode practice exams.

What I liked:

Questions are scenario-based
Detailed explanations
Explanations often teach more than the questions themselves
Difficulty is reasonably close to the real exam

Many SAP-C02 pass posts on Reddit mention Tutorials Dojo as their primary exam preparation tool, especially for getting used to long-form architectural scenarios.

My scores were not amazing initially.

I was averaging around 65–75%.

Instead of worrying about the score, I focused on understanding why I got questions wrong.

That review process was where most of the learning happened.

Day 3: Mobile Revision and Weak Areas

By the third day, I didn't want to sit at my desk anymore.

I switched to shorter review sessions throughout the day.

For quick practice sessions on my phone, I used a few different question sources, including Revizo on iOS.

What I liked about using a mobile practice engine:

Easy to review during breaks
Quick quiz sessions
Useful for reinforcing concepts repeatedly
Helps build familiarity with AWS terminology

I wouldn't rely on any single question bank alone, but having something available on my phone made it easier to squeeze in extra revision time when I wasn't at my computer.

At this stage, I wasn't trying to learn new topics.

I was simply identifying recurring mistakes and reinforcing weak areas.

Exam Day Experience

The biggest surprise wasn't the technical difficulty.

It was the mental stamina required.

SAP-C02 contains lengthy scenarios and answer choices.

Several times I narrowed questions down to two seemingly correct answers and had to choose the option that best aligned with AWS architectural best practices.

Topics that appeared frequently included:

AWS Organizations
Multi-account governance
Hybrid networking
Migration
Resiliency
Security controls
Cost optimization

Time management was critical.

If you're preparing for SAP-C02, I strongly recommend doing full-length practice exams under timed conditions before attempting the real exam.

What I Would Do Again

If I had only three days to prepare again, I would follow almost exactly the same strategy:

1. Review Weak AWS Services

Don't try to relearn everything.

Focus on areas that regularly appear in SAP-C02:

Organizations
Control Tower
Direct Connect
Transit Gateway
Route 53
DR strategies

2. Prioritize Practice Exams

Practice exams provide the highest return on investment.

For me, Tutorials Dojo delivered the most value.

3. Review Every Incorrect Answer

The explanation is often more important than the score.

4. Use Mobile Study Time

Whether it's flashcards, notes, or a practice app like Revizo, small review sessions throughout the day add up surprisingly quickly.

Final Thoughts

Could a complete beginner pass SAP-C02 in three days?

Absolutely not.

Could someone with solid AWS experience pass in three focused days?

Yes.

SAP-C02 is less about memorizing services and more about understanding architectural trade-offs at scale.

If you already work with AWS regularly, focus your preparation on practice exams, identify your weak areas, and spend your time reviewing explanations rather than chasing perfect scores.

That's exactly what worked for me.

And three days later, I walked away with a pass.