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

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 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, 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, 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, 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, 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 file for rapid readiness assessment
• One or more mock-*.json files (e.g., 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 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:

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:

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 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 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), containing credential details and domain weightings. Assessment files are organized under certifications/claude/assessments/{track-slug}/, where each subdirectory contains a 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}