Skip to main content
AR.LABSADVANCED RESEARCH LABORATORY
← Back to writing

Certified Against My Own Pipeline

Richard M. Thompson · 24 Nov 2026 · 6 min read

I was building Salesbot, a browser voice agent, and at the same time studying for Anthropic’s Claude Certified Architect exam. Somewhere in the middle of that I realised I was building a coding pipeline that itself violated some of the basic assumptions of the exam.

The pipeline on paper

On paper my pipeline was disciplined. Every coding task had a spec. Agents built it on their own branch, test first. Before any pull request there was a mandatory review by a second agent, and a person merged.

All of that was written down, in skills and rule files the agents loaded.

What the exam was really testing

A lot of the exam was about understanding which anti-pattern is causing the problem that’s being named, or which is likely to derail an agent in a particular process, and being able to apply the correct agentic architecture principle to increase the likelihood that the model will succeed.

It tries to get you to think in a particular way, away from anti-patterns and toward good-quality solutions for agents.

It immediately changed how I was approaching my use of agents.

Prompts suggest, systems enforce

Probably the most important concept for me was that without deterministic enforcement, anything written in a skill is just a suggestion.

If and when it gets difficult to follow that suggestion, or the coding agent’s context window gets full up, or something is loaded into context, earlier or as a result of the work it’s done, which conflicts with the skill: anything stored in the working memory or the context window of the model is fragile. It can be overwritten, altered and changed. The intention can be missed. And if it gets difficult to apply the skill, it can be completely ignored.

Asking the model nicely, or even choosing a better model, is not necessarily the solution. Wherever possible models need to be forced to adhere to an objective standard.

The way to resolve that is to write deterministic code: normal, old-fashioned code that checks the results of operations to ensure that the thing that’s supposed to have been done has actually been done. That’s what differentiates coding pipelines at the moment, the coding planner included: the checks made by code to ensure things have been accomplished.

I used it for: Using gates to judge pipeline stages, using Hooks

You can’t judge the work with the thinking that built it

You can’t judge the result with the same thinking, or the same agent, that built it. It reminds me of that saying “you can’t solve a problem with the same level of thinking that created it.”

The agent that’s done the work has all of the context of the problem. That context has heavily constrained the space of solutions it’s likely to think of. Judging the value of that solution from inside that limited, multi-dimensional neural problem space will just reinforce the answer it already has. It becomes an echo chamber.

Load a new agent with the problem, the solution that’s been found, and the criteria to judge whether it’s a good solution, and it’s much more likely to show up any shortcomings or errors in the thinking of the first agent.

I used it for: Developing an Adversarial Review process.

Precision in prompting

The prompt engineering material was about precision: knowing when to use explicit criteria to define a suitable type of solution, and when to use one-shot or two-shot examples that illustrate the pattern you’re aiming for.

  • Does the model need definitions of criteria so it understands how to categorise things?
  • Does it need the conceptual space to be defined by the programmer so it can categorise correctly?
  • Or does it need to be shown examples of what to look for or what to do?

It’s about precision in asking the model what is wanted and what is needed.

I used it for: Developing criteria for ‘done.’

Scoping

Then scoping: tightly scoped agents, with tight prompts and tight tool definitions, and knowing when to use them, including how many tools to give an agent.

What changed

The coding planner was one of the many things I rewrote. The review is no longer a step an agent is asked to run. Code checks that it ran, on the current commit, and refuses to go on if it didn’t.

How I studied

There are prerequisite courses on Anthropic’s Skilljar platform:

  • Claude Code 101
  • Introduction to Model Context Protocol
  • Building with the Claude API

Building with the Claude API is very in-depth. It covers the language model basics, prompt engineering, tool use, RAG, agentic search, and agents and workflows. That took about three days on its own. The prerequisites took at least a week, followed by at least another week of intensive exam prep.

I did five or six learning sessions across a number of weeks. I took the official Anthropic mock exam twice, then did flashcard-style studying of the exam questions and a fair bit of reading about the principles behind them.

The mock exam is very good at showing your weak areas. On the first one I completely ran out of time, because I didn’t realise you have to answer one question every two minutes. The questions are dense and really require you to know what you’re looking at and what Anthropic is expecting.

The part that came most naturally to me was the agentic architecture: how to construct the use of sub-agents, and how to put together sequences of workflows and of different agents. The hole was CI/CD pipelines. The first mock exam made that obvious, and I had to double down on it.

The exam

The exam is proctored. You turn up at a set time and set up your webcam, and somebody watches you the whole time. You can’t leave your desk. You show them your desk and the room so they know you’re not cheating, and they watch your computer to make sure you’re not using AI.

All in all it’s quite an intensive process. I was a bit surprised at how intensive. But I was very happy that, in the end, I got 905 out of 1,000.