# Purpose of the Certifications Directory in AI Engineering From Scratch

> Discover the purpose of the certifications directory in AI Engineering From Scratch. It formalizes the curriculum into structured certification tracks with labs and assessments.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: how-to-guide
- Published: 2026-08-26

---

**The `certifications` directory transforms the open-source AI Engineering From Scratch curriculum into formal, self-contained certification tracks for Claude credentials**, providing structured learning paths, runnable labs, and automated assessment tools.

The `ai-engineering-from-scratch` repository by rohitg00 extends its core lessons into professional credentialing through a dedicated `certifications` directory. This directory houses the complete infrastructure needed to prepare for official Claude certifications, from curriculum metadata in [`program.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/program.json) to hands-on code labs. Unlike traditional study guides, this implementation provides executable lesson artifacts and automated validation tooling that mirror real exam conditions.

## Architecture of the Certifications Directory

The directory follows a layered architecture that separates curriculum metadata from runnable learning content. At the root, [`certifications/README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/README.md) defines the high-level program overview, while nested directories within `certifications/claude/` contain machine-readable schemas and lesson implementations.

### Curriculum Metadata and Program Structure

The [`certifications/claude/program.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/program.json) file stores machine-readable credential definitions, including exam versions and weighting schemes used by the learner-tutor system. This JSON structure drives the routing logic for the four available tracks: **Claude Certified Associate (CCAR-F)**, **Developer (CCDV-F)**, **Architect Foundations**, and **Architect Professional**.

### Prerequisite Dependency Graph

Learning order is enforced through [`certifications/claude/prerequisites.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/prerequisites.json), which implements a **directed acyclic graph (DAG)** of lesson dependencies. This ensures learners complete foundational multi-agent orchestration concepts before advancing to complex architectural patterns, maintaining pedagogical integrity across the curriculum.

### Track Definitions

Individual credential routes are defined in `certifications/claude/tracks/*.json` files. For example, [`ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-f.json) contains the ordered lesson list for the Claude Certified Associate - Foundations track, mapping directly to the official exam blueprint stored in the research directory.

## Lesson Structure and Runnable Labs

Each lesson within `certifications/claude/lessons/` follows a strict contract identical to the core curriculum. The directory `16-multi-agent-orchestration-and-delegation/` exemplifies this structure, containing documentation, executable code, unit tests, expected outputs, and quizzes.

### Code Artifacts and Verification

The `code/` subdirectory within each lesson contains [`main.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/main.py) entry points and comprehensive test suites. Learners execute these files to build the exact systems described in official exam guides, then validate their implementations against the provided tests using `python3 -m unittest discover`.

### Assessment and Practice Exams

The `certifications/claude/assessments/` directory contains mock diagnostics that replicate the structure and difficulty of official Claude exams. Files like [`ccar-f/diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-f/diagnostic.json) store question banks and scoring rubrics in machine-readable format, enabling realistic practice conditions.

## Local Development and Validation

The certification system includes automated tooling to validate lesson integrity and generate browsable documentation without external dependencies.

### Building the Certification Site

Generate and serve the local certification catalog using the site's build pipeline:

```bash

# From the repository root

node site/build.js                # Generates site/data.js and site/certifications.html

python3 scripts/audit_certifications.py   # Checks lesson integrity and JSON schemas

python3 -m http.server 4173 --bind 127.0.0.1   # Serve the site locally

```

Navigate to `http://127:0.0.1:4173/site/certifications.html` to explore the full certification catalog.

### Running Individual Lessons

Execute lesson artifacts and verify correctness:

```bash
cd certifications/claude/lessons/16-multi-agent-orchestration-and-delegation/code
python3 main.py                 # Executes the lesson’s runnable artifact

python3 -m unittest discover    # Runs the 5+ unit tests that verify correctness

```

### Programmatic Assessment Inspection

Inspect diagnostic structures for custom study tools:

```python
import json, pathlib

diag_path = pathlib.Path("certifications/claude/assessments/ccar-f/diagnostic.json")
diag = json.loads(diag_path.read_text())
print(f"Diagnostic has {len(diag['questions'])} questions")

```

This JSON-based approach allows for automated validation and integration with third-party study applications.

## Research and Curriculum Provenance

The `certifications/claude/research/` directory maintains educational transparency through verification ledgers and source documentation. Files like [`official-blueprint-map.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/official-blueprint-map.md) justify curriculum decisions and track alignment with official exam updates, ensuring the material respects exam integrity while remaining community-driven.

## Summary

- The `certifications` directory provides **four structured credential tracks** (Associate, Developer, Architect Foundations, Professional) with dependency-managed learning paths defined in [`prerequisites.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/prerequisites.json).
- **Runnable lesson artifacts** in `certifications/claude/lessons/<lesson-slug>/` include code, tests, and expected outputs that mirror official exam requirements.
- **Machine-readable metadata** in [`certifications/claude/program.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/program.json) drives automated tutoring and route validation.
- **Mock assessments** in JSON format replicate official exam conditions for realistic practice without external dependencies.
- **Automated tooling** ([`scripts/audit_certifications.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/audit_certifications.py), [`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js)) validates lesson integrity and generates the browsable HTML catalog at [`site/certifications.html`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/certifications.html).

## Frequently Asked Questions

### What specific Claude certifications does the directory cover?

The directory supports the full Claude certification portfolio including **CCAR-F** (Certified Associate), **CCDV-F** (Certified Developer), and the **Architect-level credentials** (Foundations and Professional). Each track is defined in separate JSON files within `certifications/claude/tracks/`, with lesson sequences mapped to official exam blueprints.

### How does the prerequisite system ensure proper learning order?

The [`certifications/claude/prerequisites.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/prerequisites.json) file implements a directed acyclic graph that enforces lesson completion order. This graph structure ensures learners master foundational concepts like multi-agent orchestration before attempting advanced architectural patterns, preventing knowledge gaps in the certification preparation process.

### Can I run the certification lessons without installing external dependencies?

Yes, the curriculum is designed to be educationally pure, requiring only the Python standard library and optionally Node.js for site generation. All lesson code in `certifications/claude/lessons/<lesson>/code/` runs locally with built-in unit tests for verification, maintaining reproducibility across different environments.

### Where are the practice exams and diagnostics located?

Mock diagnostics and full-length practice exams are stored in `certifications/claude/assessments/<credential>/`, with JSON files like [`diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/diagnostic.json) containing structured questions that mirror the official exam format. These files can be parsed programmatically or rendered through the local site build for interactive practice.