The benefits of AI/LLMs are debated passionately across fields, and that applies to software engineering as well. Whether you like it or not, LLMs have changed how we build software, ranging from "LLMs have solved coding. AGI is here." to "It's a bubble. Who pays for the tokens? It's not sustainable." But at the end of the day, LLMs are a tool that is here to stay in some form. Understanding it, maximizing the efficiency of usage, building proper tooling around it, and using it responsibly are engineering problems. One of the certifications that enable me to tackle that problem is the CCA-F by Anthropic.

What CCA-F Actually Tests

CCA-F is a proctored 2-hour exam where you have to answer 60 questions. It's from Anthropic, so the exam is centered around their products: Claude Agent SDK, Claude Code, and Claude API, but also on topics like MCP, which is applicable widely. It's an exam which tests your ability to take architectural decisions instead of whether you know the jargon and trivia. As such, one must have trained to think of tradeoffs and how to tackle common problems that come from the experience of building such systems.

While this seems narrow, the lessons learnt from studying for this exam are applicable outside of Anthropic products.

Here is an link to the official exam page.

Where I Already Had an Edge

The exam is structured around five domains, each carrying a different weight toward the final score:

Domain	Weight
Agentic Architecture & Orchestration	27%
Tool Design & MCP Integration	18%
Claude Code Configuration & Workflows	20%
Prompt Engineering & Structured Output	20%
Context Management & Reliability	15%

Going in, my prep looked less like starting from zero and more like auditing what I already knew against what the exam actually wanted.

Agentic Architecture was the heaviest-weighted domain, and also the one I felt confident about. I'd already studied agentic systems and patterns before ever opening the exam guide, and dabbled with toy projects of my own, so concepts like coordinator-subagent orchestration and loop control weren't new vocabulary — they were things I'd already made real decisions about.

Tool Design & MCP Integration was similarly familiar ground. I'd built a few MCPs for work and for my own personal productivity, which meant tool description design and MCP server scoping weren't abstract best practices to memorize — they were lessons I'd already learned the hard way.

Claude Code Configuration was the one domain that genuinely stretched me. I hadn't used it before sitting the exam, so unlike the previous two, I couldn't lean on adjacent experience. I had to actually get hands-on with CLAUDE.md hierarchies, custom commands, and plan mode from a standing start.

Prompt Engineering & Structured Output turned out to overlap with something I hadn't expected to be relevant: I'd previously tried setting up a small language model to gamify my own habits, and that gave me a working feel for few-shot design and getting reliable structured output out of a model, long before I connected it to this exam.

Context Management & Reliability came from an even less obvious place — using GitHub Copilot at work. Long sessions with it had already put me face-to-face with context degradation and the practical need to compact or reset before the model started losing the thread, so this domain felt less like new material and more like putting a name to something I'd already been managing intuitively.

The key part here is that I had hands-on experience which helped a lot. Anthropic provides courses that help on their Skilljar site, but a lot of it has to come from hands-on experience — failing and learning.

How I Prepared

I spent about a month to a month and a half — just weekends, an hour or two per day, preparing for the exam. I used two types of resources along the way: Anthropic's own courses on Skilljar, and claudecertificationguide.com.

Skilljar laid the foundations and taught me the vocabulary and the structure, while the exam site helped me refine what I learnt. It became a loop of learning the concept, learning patterns and anti-patterns, associating my experience with said learnings, and taking mock tests.

claudecertificationguide.com also gives you hands-on exercises, but I never made use of them. It has other features at your disposal as well.

Exam Day

The exam is delivered through Pearson VUE, online and proctored the entire way through, with video and audio monitoring for the full session. Check-in starts 30 minutes before your actual exam window. You log in early and use your phone to walk the proctor through your desk setup and verify your identity before you're allowed to begin. Only once that's cleared does the two-hour clock actually start.

The format itself is straightforward on paper. There are 60 questions, drawn from four scenarios out of a possible six, with each scenario anchoring a run of related questions rather than firing off disconnected one-liners. Anthropic allots two hours for the exam proper. I didn't need anywhere near that; I finished in an hour and ten minutes.

If there's one adjustment worth making going in, it's this: budget real time for the check-in itself, separate from the exam window. Between the 30-minute login buffer and the phone-based desk and ID verification, you're looking at close to an hour of proctoring overhead before the first question even loads. Plan your schedule around the full block, not just the two-hour exam number on the certification page.

I walked away with a passing score of 865 out of 1,000, well clear of the 720 cut-off.

The Verdict

Absolutely! Beyond the credential itself, it sharpened how I think about designing agentic systems, not just the mechanics, but the judgment calls: when to reach for a coordinator-subagent pattern versus a simpler single-agent loop, when a hook is the right tool instead of another line in a prompt. It gave me a sharper lens on problems I'd already been wrestling with, and more than once I found myself reframing something I'd built months ago in light of what the exam pushed me to understand. Learning the common anti-patterns did as much for me as learning the right patterns. Knowing exactly how and why an approach fails is often more useful than knowing the textbook-correct one, because it's the failure mode you actually recognize in the moment.

If you're serious about building workflows, agents, or automating a process with LLMs, this is a genuinely good starting point. It isn't an easy certification, and it isn't meant to be, but that's precisely what makes it worthwhile. It doesn't reward memorization; it rewards having actually gotten your hands dirty building the things it asks about.

No regrets. If anything, it confirmed I was already thinking about these systems the right way, and gave me the vocabulary and a few sharper edges to go with it.

If any of this was interesting, I'm hoping to write about this kind of thing fairly often, please subscribe if you want it in your inbox. Thoughts, disagreements, or your own experience with AI systems? Drop a comment, I read them. And if you want to find me elsewhere: goodreads, letterboxd, github and linkedin.