# Claude Certification Tracks and Assessment Schemas: How diagnostic.json and mock-*.json Differ

> Explore Claude certification tracks and understand how diagnostic.json differs from mock-*.json schemas. Get rapid skill checks and answer keys for AI engineering.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: api-reference
- Published: 2026-08-29

---

**The `rohitg00/ai-engineering-from-scratch` repository supports four Claude certification tracks—Developer Foundations (CCDV-F), Architect Foundations (CCAR-F), Architect Professional (CCAR-P), and Architect Core (CCAO-F)—each utilizing two distinct JSON assessment schemas where [`diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/diagnostic.json) provides educational explanations for rapid skill checks, while `mock-*.json` files contain answer keys without explanations for full-length practice exams.**

This open-source curriculum structures Claude certification preparation through track definitions stored under `certifications/claude/tracks/` and corresponding assessments in `certifications/claude/assessments/`. Understanding the schema differences between diagnostic and mock exam files ensures you select the appropriate evaluation tool for your study phase.

## Supported Claude Certification Tracks

The repository defines four distinct certification tracks, each targeting specific professional roles and technical depths:

- **CCDV-F (Developer Foundations)**: Defined in [`certifications/claude/tracks/ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccdv-f.json), this track focuses on building, integrating, testing, and shipping Claude applications, agents, workflows, and MCP servers. The exam code is **CCDV-F**.
- **CCAR-F (Architect Foundations)**: Located in [`certifications/claude/tracks/ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccar-f.json), this foundational architecture track covers model selection, prompting strategies, context engineering, and basic tool usage. The exam code is **CCAR-F**.
- **CCAR-P (Architect Professional)**: Found in [`certifications/claude/tracks/ccar-p.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccar-p.json), this professional-level track addresses end-to-end system design, governance, evaluation frameworks, and large-scale production deployments. The exam code is **CCAR-P**.
- **CCAO-F (Architect Core)**: Stored in [`certifications/claude/tracks/ccao-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccao-f.json), this core architecture track emphasizes robust solution design including tool contracts, security patterns, and observability. The exam code is **CCAO-F**.

Each track JSON contains a structured **assessments** array that references both a diagnostic file and one or more mock exam files.

## Assessment File Structure and Location

Assessment files follow a consistent directory pattern under `certifications/claude/assessments/{track-slug}/`. For example, the Developer Foundations track stores its evaluations in `certifications/claude/assessments/ccdv-f/`.

Every track directory contains:

- A [`diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/diagnostic.json) file for rapid readiness assessment
- One or more `mock-*.json` files (e.g., [`mock-01.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/mock-01.json)) simulating official certification conditions

These files are referenced by the track definition's assessments array and loaded by the repository's evaluation runners.

## Schema Differences Between diagnostic.json and mock-*.json

While both schemas share core question metadata—`id`, `domain`, `objective`, `type` (`single` or `multiple`), `prompt`, and `options`—they diverge significantly in pedagogical approach, answer storage, and temporal constraints.

### Purpose and Duration Constraints

**[`diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/diagnostic.json)** functions as a lightweight skill check, typically allocating **30 minutes** (`timeLimitMinutes: 30`) for 10-20 questions that sample representative domains. This format provides rapid feedback on readiness gaps.

**`mock-*.json`** replicates the full certification experience, requiring approximately **120 minutes** (`timeLimitMinutes: 120`) to complete 40-60+ questions covering all domains defined in the track. This schema mirrors the official exam's timing and scope.

### The `kind` Field and Type Identification

Every assessment file declares its schema type through the **`kind`** field for programmatic routing:

```python
import json

def is_diagnostic(data: dict) -> bool:
    return data.get("kind") == "diagnostic"

def is_mock(data: dict) -> bool:
    return data.get("kind") == "mock"

# Usage

with open("certifications/claude/assessments/ccdv-f/diagnostic.json") as f:
    diag = json.load(f)
    
with open("certifications/claude/assessments/ccdv-f/mock-01.json") as f:
    mock = json.load(f)

print(is_diagnostic(diag))  # True

print(is_mock(mock))        # True

```

Diagnostic files specify `"kind": "diagnostic"`, while mock files declare `"kind": "mock"`.

### Question Object Structure and Answer Storage

The **diagnostic schema** prioritizes learning through detailed metadata:

- **`correct`**: An array of integers representing valid option indices
- **`explanation`**: Detailed reasoning explaining why the correct answer is valid
- **`references`**: Links to documentation or source materials for further study

Conversely, the **mock schema** maintains exam integrity by withholding pedagogical content:

- **`answer`**: Contains the solution as a single integer (for `single` type) or array (for `multiple` type)
- **Omits** both `explanation` and `references` fields to prevent answer disclosure during practice sessions

### Scoring Mechanisms

The diagnostic runner calculates scores using the `correct` array while displaying explanations for wrong answers. The mock runner validates submissions against the `answer` key using the exact scoring logic implemented in the production certification exam, providing binary correct/incorrect feedback without reasoning.

## Loading and Validating Assessment Files Programmatically

You can interact with these schemas using standard Python library modules to build custom study tools:

```python
import json
import pathlib

def load_track(slug: str) -> dict:
    """Read a track JSON and return credential and exam metadata."""
    path = pathlib.Path(
        "certifications/claude/tracks",
        f"{slug}.json"
    )
    with path.open() as f:
        return json.load(f)

def load_assessment(track_slug: str, filename: str) -> dict:
    """Load either diagnostic or mock assessment for a specific track."""
    path = pathlib.Path(
        "certifications/claude/assessments",
        track_slug,
        filename
    )
    with path.open() as f:
        return json.load(f)

# Load track metadata

track = load_track("ccdv-f")
print(f"{track['credential']} → {track['exam']['items']} items")

# Load and classify assessments

diag = load_assessment("ccdv-f", "diagnostic.json")
mock = load_assessment("ccdv-f", "mock-01.json")

print(f"Diagnostic kind: {diag.get('kind')}")
print(f"Mock kind: {mock.get('kind')}")

```

## Summary

- The repository supports **four Claude certification tracks**: CCDV-F (Developer Foundations), CCAR-F (Architect Foundations), CCAR-P (Architect Professional), and CCAO-F (Architect Core), each defined in `certifications/claude/tracks/`.
- **[`diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/diagnostic.json)** provides 30-minute skill assessments with 10-20 questions, including `explanation` and `references` fields for educational feedback.
- **`mock-*.json`** delivers 120-minute practice exams with 40-60+ questions, using an `answer` key field while omitting explanations to simulate official testing conditions.
- Both schemas identify their type via the **`kind`** field and contain standardized question metadata including `domain`, `objective`, and `options`.
- Track definitions link to these assessments through the assessments array, enabling automated curriculum routing.

## Frequently Asked Questions

### What are the four Claude certification tracks supported in the repository?

The repository defines Claude Certified Developer – Foundations (CCDV-F), Claude Certified Architect – Foundations (CCAR-F), Claude Certified Architect – Professional (CCAR-P), and Claude Certified Architect – Core (CCAO-F). Each track targets distinct competency levels, from application development to enterprise architecture, with corresponding JSON definitions stored under `certifications/claude/tracks/`.

### How does the diagnostic.json schema differ from mock-*.json in structure and content?

The [`diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/diagnostic.json) schema includes a `correct` array alongside `explanation` and `references` fields to facilitate learning, while `mock-*.json` files replace these with a single `answer` field (integer or array) and omit educational metadata. This structural difference ensures mock exams test knowledge retention without revealing reasoning, whereas diagnostics prioritize skill gap analysis.

### Where are certification track definitions and assessment files located within the repository?

Track definitions reside in `certifications/claude/tracks/` (e.g., [`ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccdv-f.json)), containing credential details and domain weightings. Assessment files are organized under `certifications/claude/assessments/{track-slug}/`, where each subdirectory contains a [`diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/diagnostic.json) and one or more `mock-*.json` files referenced by the parent track definition.

### Can I programmatically determine if an assessment file is a diagnostic or mock exam?

Yes, inspect the **`kind`** field value at the root of the JSON object. Diagnostic assessments specify `"kind": "diagnostic"`, while mock exams specify `"kind": "mock"`. This field enables automated parsers to route files to appropriate scoring logic and UI renderers without relying on filenames alone.