Henry KobinIndependent project
Learn
A certification review platform, built with Claude Fable 5.1.
The idea
I have been building agentic systems for a few years. When I decided to sit NVIDIA’s Agentic AI Professional exam, the problem was not learning the material. It was having one trustworthy place to review it in the exam’s own terms, with the gaps made visible. Vendor study guides are reading lists, and third-party practice sites are uneven.
So I built the place I wanted, and I built it as a platform rather than a one-off: a content model, a registry of exams, validators, and a review pipeline, so the next certification is a content pack rather than a new site. The first guide is an 18-chapter book for NCP-AAI with 484 practice questions, 38 runnable code cells, and 235 flashcards.
I built it with Claude Fable 5.1 in one working day. I set the structure, the voice, and the running example; parallel agents drafted the chapters; adversarial review agents and continuity passes caught mistakes; and I read, corrected, and shipped it.
Review, not first contact
The dashboard is built for someone who already knows the field and wants to see where the exam will find them weak. Readiness weights each blueprint domain by its share of the exam and fills it with your mastery there. Below it, the weakest objectives surface from the questions you have missed, and a twelve-week calendar keeps the habit honest.
The book reads in an order that builds, while the exam is organized by domain. A separate domains page maps every objective back to the chapters that cover it, so you can study by weight when the exam is close.
- chapters
- 18
- practice questions
- 484
- flashcards
- 235
- runnable code cells
- 38
A textbook with a running example
Every chapter has the same skeleton: where we are, what you will be able to do, sections that each introduce one idea, an exam-angle box, key terms, and a check of six to eight scenario questions with an explanation on every option. One running example, a support agent called Atlas, gains a layer per chapter, so later chapters build on code and decisions you have already seen.
The eighteen chapters go from the agent loop through reasoning, tools, memory, planning, reliability, retrieval, multi-agent systems, the NVIDIA stack, inference optimization, guardrails, evaluation, deployment, operations, safety, and human oversight.
- Exam angle
- Each chapter ends with the three to six scenario-to-answer mappings most likely to be tested, so a fast pass is possible.
- One term per concept
- A 287-term glossary is the source of truth; prose links the first use of each term and lists the synonyms an exam question might use.
- Cross-references
- Chapters link forward and back by number, and a validator fails the build if a link or a term does not resolve.
Diagrams you can drive, code you can run
Interactives are small React components: a ReAct loop stepper, a batching timeline that animates static versus in-flight batching, a retry-and-backoff simulator, a hybrid-search explorer, a Pareto explorer for accuracy against latency, an EU AI Act tier quiz, an approval-gate simulator. Each shows the mechanism rather than a picture of it.
Code cells run in the browser. Python runs in Pyodide inside a web worker; JavaScript runs in a second worker. Cells ship with a deterministic mock model so every example works offline, and a Live toggle swaps in a real model from any OpenAI-compatible endpoint the reader configures, which also turns on a chapter-scoped tutor.
Practice that feeds the readiness model
The mock exam samples 65 questions by domain weight, runs the real 120-minute clock, supports flagging and pausing, and scores by domain with every explanation afterward. Flashcards use a spaced-repetition schedule. Any text in a chapter can be highlighted and saved, or sent to the tutor with “explain this.” Missed questions get an “explain my mistake” button when a model is connected.
Every answer, in a chapter check, a practice set, or a mock, updates the same mastery model, so the dashboard reflects everything you have done.
How I built it with Fable
The structure came first: the content model, the chapter skeleton, the voice rules, the fixed facts of the running example, and a per-chapter spec with the glossary terms each chapter owns. I wrote the first chapter as the exemplar. Then one agent per chapter drafted the rest in parallel, creating only new files so nothing collided, and a registration script wired them in.
Review was adversarial. For each chapter, one reviewer listed questionable answer keys and claims, two independent skeptics tried to refute each finding, and only findings that survived both were fixed. Two continuity passes then aligned terms, cross-references, and the running example across all eighteen chapters.
Specs and exemplar
Content model, chapter skeleton, voice, fixed facts, and one finished chapter to copy.
Parallel authors
One agent per chapter, new files only; the integrator registers and validates.
Mechanical checks
TypeScript, a content validator for every rule, and a runner that executes all 38 code cells with the same mock model the site uses.
Adversarial review
Reviewer, two skeptics per finding, fix agent; 19 confirmed corrections across the book.
Continuity
Two passes for term drift, chapter references, and running-example facts.
The content can still be wrong, and NVIDIA’s products change quickly. The site says so on its first page and asks readers to verify against official documentation.
Nothing leaves the browser
There is no account and no server. Progress, highlights, and notes live in the browser’s storage and can be exported and imported as a file. Code runs locally in WebAssembly. An API key, if a reader adds one, stays on their machine and is sent only to the endpoint they chose; it is excluded from exports.
- Static hosting
- A Vite build on Cloudflare Pages, deployed from a protected branch; the work branch never deploys.
- Honest notice
- The first visit shows a short notice: independent, not affiliated with NVIDIA, original practice questions, built with Claude Fable 5.1, mistakes possible.
Built for the next exam
Exams are content packs. Each one is a folder with metadata, domains and objectives, chapters, questions, flashcards, a glossary, resources, and study plans, registered in one line. The hub lists whatever is registered and shows progress per exam. The authoring pipeline, the validators, and the review workflow are documented in the repository so the next guide can be built the same way.
Next on the list are the Certified Kubernetes Administrator and NVIDIA’s AI Operations certification, which is where my inference-platform work points.