I passed the Claude certification by a single question

Today I sat the Claude Certified Developer – Foundations exam.

The passing score is 720. I scored 720.

Not a point more. If a single question had gone the other way, this would be a different post, a lot shorter and a lot less happy. So I’m going to tell it as it was: with the relief, but also with everything that number says about how I studied.

Finishing the courses isn’t knowing

I started where almost everyone starts: with the courses. I watched them, took notes, nodded along. Then came the recommended material: documentation, articles and videos that did help me understand concepts I had skimmed past in the courses. I won’t play that down: without that grounding I wouldn’t even have known what to ask myself.

But at the end I had that comfortable feeling of “I get this now”.

The trouble is that feeling can’t be measured. Understanding an explanation while someone gives it to you is very different from picking the right answer when four options all sound reasonable and none of them warns you which one is the trap.

And in this exam nearly every option sounds reasonable. Raising max_tokens does fix truncation. But if the scenario says the team wants to spend fewer tokens, it’s the wrong answer. The certification doesn’t ask what each parameter does. It asks what you would do in a specific situation, with specific constraints.

I needed to practise that way. And I needed to know, not guess, what I knew and what I didn’t. Reading and watching gave me the concepts. What got me through was what came after.

I built LoreGap

I looked for question banks, and what I found were, at best, quizzes: you answer, it tells you if you were right, you move on. That gives you a score. It doesn’t tell you what matters:

• What do I actually understand?
• What am I getting right by luck?
• What am I wrong about while being sure I’m right?
• What am I starting to forget?
• What should I study next?

So on 9 September I started writing LoreGap, a macOS app that works offline, with no account and no server. It’s a study system, not a quiz game.

The core idea is that the unit of knowledge isn’t the question, it’s the concept. Every question is evidence about one or more concepts. And every time you answer, as well as picking an option, you say how sure you were: guessing, unsure, confident or certain.

A question on prompt injection in a practice session. Every option explains why it is right or wrong, and below, the app asks how sure you were before answering.

With those two things — whether you were right and how sure you were — every answer lands in one of four cases:

	Sure	Not sure
Right	Solid knowledge	Fragile knowledge
Wrong	Misconception	Gap

The scariest one is bottom left. Getting something wrong while unsure is normal: you didn’t know, that’s all. Getting it wrong while sure means you believe something that isn’t true, and that’s far more dangerous, because on exam day you’ll pick that answer without a second thought.

LoreGap puts those concepts first, schedules reviews at intervals, and keeps track per exam domain, weighted by how much each one counts in the certification.

Claude writing questions about Claude

A study app without questions is useless. And writing good multiple-choice questions is much harder than it looks.

That’s where I leaned on Claude, for three different things.

Generating. I’d ask for questions on a specific concept, as a scenario: a team, a problem, a constraint, four options. The point wasn’t the question, it was the distractors. A question where three options are obviously absurd trains nothing. The good ones have options that are correct in another context, and the whole exercise is noticing why they aren’t in this one.

Correcting. This was the most laborious part and, honestly, the most useful. A model can write a very convincing question with an outdated fact, or with a “wrong” option that is actually defensible too. So every question went through a second round: check it against the documentation, argue about the answer, hunt for ambiguity, ask “is there a reading where option B is also right?”. More than once the answer was yes, and it had to be rewritten. Arguing with Claude about whether a question was well made taught me more than answering it.

Explaining. Every option, not only the right one, has its own explanation of why it’s right or wrong in that particular scenario. Getting it wrong and reading why your option was reasonable, just not here is exactly the learning the courses don’t give you.

It all lives in YAML files, versioned in Git, separate from the code. Adding or fixing a question doesn’t touch the app’s logic. If you look at the repository history, most commits look like this: “Add a question on reading 401 against 403”, “Add a question on which API errors are worth retrying”, “Add a question on Haiku 4.5’s minimum cacheable length”. One question, one commit, one thing I didn’t know.

The practice loop

The routine ended up roughly like this:

1. Run a session in LoreGap, rating confidence honestly (harder than it sounds: the ego wants to tap “confident”).
2. Go back through the session question by question at the end.
3. Copy the study prompt the app builds and keep reviewing with an assistant.
4. Whenever I found a concept the bank didn’t cover, write a new question about it.

The feature I like most

I added step 3 near the end, and I think it’s the most important thing LoreGap has.

When a session ends, the app builds a prompt with every question you answered, grouped by what it revealed: first the ones you got wrong while sure, then the ones you got wrong while unsure, then the ones you got right without being sure. Each comes with the question, the options in the order you saw them, your answer, your confidence, the right answer and the explanation. The ones you got right and sure only appear by name, so nobody wastes time there. And each group carries its own instruction, such as “These matter most: I believe something that is not true. Explain the mistake in my reasoning, not only the right answer.”

Copy it, paste it into Claude, ChatGPT or whatever assistant you use, and you have a tutoring session tailored to that day’s mistakes.

What I like most is what it doesn’t do. LoreGap doesn’t connect to any AI, doesn’t ask for an API key and doesn’t send anything anywhere: the text is built offline and only copied to the clipboard. The app does what an app does well — measure, sort, remember what you got wrong — and leaves the model to do what a model does well: talk it through, explain it another way, answer “but why not B?” until it clicks.

A twenty-question session tells you what you don’t know. The conversation afterwards is where you learn it.

The suffering

I won’t pretend it was a tidy path.

There were nights I finished a session feeling I knew nothing. Concepts I’d review, get right with confidence, and two days later get wrong again. Questions I had written myself, explanation and all, that I still got wrong. That is humbling in a very particular way.

And there was, of course, the classic programmer’s temptation: spending more time improving the tool than using it. The app icon went through three design rounds. There are commits from the small hours. At some point I had to admit that polishing LoreGap was also an elegant way of not studying.

I wrote the last batch of questions two days before the exam. Things that still felt shaky: migrating off a deprecated model before it retires, why a billing role can’t create API keys, the per-request image limit. Version 0.4 shipped the night before.

The result, unretouched

720 out of the 720 needed. Pass.

But the per-section breakdown is more honest than the final number:

At 100%	At 0%
Prompt Engineering, Hooks, MCP Dev, Claude Code Operation, AI App Security, Config Management, Agent Construction, Agent Patterns, Identity/Secrets, Tech Fundamentals	Model Selection, Cost/Token Management, Guardrails, Tool Implementation, Understanding Requirements

What makes me think most is this: Model Selection was one of the domains where I had the most questions in the bank. And I scored zero.

Maybe the exam’s questions were different from mine. Maybe I held a misconception that never surfaced because my own questions never touched it. Probably both. A question bank you write yourself has the same blind spots you do, however much AI helps.

And the other way round: the topics at 100% are almost all things I use every day. Hooks, MCP, Claude Code. Work helped a lot there, but using something every day doesn’t guarantee you understand the detail an exam asks about. I found that out by practising: finding what I thought I knew and didn’t, before the exam rather than during it, is exactly what I built LoreGap for.

If I have to share out the credit, the courses, the reading and the videos gave me the concepts. But the 720 goes to LoreGap.

What I’m taking away

Courses give you the map, not the terrain. Finishing them is the starting point, not the preparation.

Measuring confidence changes everything. Knowing you were right says little. Knowing you were right while guessing tells you exactly where the risk is.

AI works better as a study partner to argue with than as a source. The questions Claude generated were a draft. The learning was in reviewing them, arguing about them, finding what was wrong and fixing it. And after every session, in talking through my mistakes rather than the whole syllabus.

A bank you build yourself inherits your blind spots. If I started again, I’d deliberately go after questions on the topics that interest me least, because that’s where my zeros were.

Passing by a hair is still passing. But it’s also a very clear list of what to study next.

What’s next

LoreGap doesn’t end with this exam. For now the bank covers the Developer certification, but I’ll keep adding questions: first to fill in the zeros on this report, then to aim at the Architect certification. And in twelve months it’s time to renew, so the bank has to stay alive either way.

Today is for celebrating. Tomorrow, probably, is for writing a few questions on model selection.

---

LoreGap is for macOS, works offline, keeps everything on your Mac and sends nothing anywhere. Download it from infante.io/loregap.