What Reusable Artifacts Are Produced by Each Lesson in the AI Engineering Curriculum

Each lesson in the rohitg00/ai-engineering-from-scratch curriculum deposits two primary reusable assets: a human-readable Markdown skill file (skill-*.md) and a machine-readable JSON report (*_report.json), both stored in predictable outputs/ directories.

The repository organizes learning modules into phases and lessons that follow a strict artifact contract. Every implementation writes portable reusable artifacts to the filesystem, enabling engineers to compose curriculum components into production pipelines without recreating logic from scratch.

Types of Reusable Artifacts Generated

The curriculum produces three distinct artifact categories designed for immediate downstream consumption.

Skill Markdown Files

The primary consumable output is a Skill Markdown file following the skill-*.md naming convention. These files capture the lesson's core capability—such as a safety gate configuration, prompt engineering protocol, or routing logic—in a human-readable format suitable for documentation or direct copy-paste into other projects.

For example, phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/skill-end-to-end-safety-gate.md contains the complete safety gate specification implemented in that lesson. Similarly, phases/18-ethics-safety-alignment/21-fairness-criteria-group-individual-counterfactual/outputs/skill-fairness-criterion.md documents ethics protocols, while phases/17-infrastructure-and-production/20-shadow-canary-progressive/outputs/skill-rollout-runbook.md defines deployment patterns.

Machine-Readable Reports

Lessons that involve evaluation or auditing generate structured JSON reports (typically named *_report.json) and line-delimited JSON logs (*.jsonl). These artifacts encode rules engines, taxonomies, training losses, or evaluation metrics.

The file phases/19-capstone-projects/86-constitutional-rules-engine/outputs/rules_report.json demonstrates this pattern, storing constitutional rule definitions that downstream automation can parse programmatically. Training-focused lessons like phases/19-capstone-projects/36-training-loop-eval/outputs/losses.jsonl provide chronological loss data for reproducibility analysis.

Auxiliary Data Files

Some lessons emit lightweight text artifacts that support debugging and historical tracing without requiring manual parsing of stdout logs. These are typically found alongside the primary Markdown and JSON outputs in the lesson's outputs/ folder.

Artifact Storage Conventions

All reusable artifacts follow a rigid directory hierarchy to facilitate discovery and import:

phases/<phase-slug>/<lesson-slug>/outputs/

This structure separates implementation code (code/main.<lang>) from generated assets. For instance, the capstone lesson on content classifier integration stores its skill artifact at phases/19-capstone-projects/85-content-classifier-integration/outputs/skill-content-classifier-integration.md.

The contract is consistent across all phases:

1. Implementation (code/main.py or equivalent) – Executes the lesson logic and writes artifacts.
2. Tests (code/tests/) – Validate correctness against the generated outputs.
3. Outputs (outputs/) – Store the final reusable artifacts.

Consuming Reusable Artifacts in Production Code

Because artifacts are plain text and JSON, they integrate with any language ecosystem. The following snippets demonstrate how to load these assets into downstream applications.

Loading a Skill Markdown File in Python

import pathlib, markdown

# Load the safety gate skill from lesson 87

skill_path = pathlib.Path(
    "phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/"
    "skill-end-to-end-safety-gate.md"
)
skill_md = skill_path.read_text()
html = markdown.markdown(skill_md)

print("Rendered skill description:", html[:200], "...")

Parsing a JSON Report in Node.js

import fs from "fs";

// Load the constitutional rules report from lesson 86
const reportPath = "phases/19-capstone-projects/86-constitutional-rules-engine/outputs/rules_report.json";
const report = JSON.parse(fs.readFileSync(reportPath, "utf8"));

console.log("Number of rules:", report.rules.length);
console.log("First rule:", report.rules[0].description);

Representative Artifact Examples Across the Curriculum

The following index maps specific source paths to their artifact types, illustrating the breadth of components available for reuse:

• Safety Gate Skill: phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/skill-end-to-end-safety-gate.md captures the end-to-end safety implementation.
• Constitutional Rules JSON: phases/19-capstone-projects/86-constitutional-rules-engine/outputs/rules_report.json stores machine-readable rule definitions.
• Content Classifier Skill: phases/19-capstone-projects/85-content-classifier-integration/outputs/skill-content-classifier-integration.md documents the integration pattern.
• Fairness Criterion Skill: phases/18-ethics-safety-alignment/21-fairness-criteria-group-individual-counterfactual/outputs/skill-fairness-criterion.md provides ethics alignment protocols.
• Tool Interface Reviewer: phases/13-tools-and-protocols/01-the-tool-interface/outputs/skill-tool-interface-reviewer.md defines tool integration standards.

Summary

• Every lesson writes at least one Markdown skill file (skill-*.md) to its outputs/ directory, documenting the implemented component for human consumption.
• Evaluation-heavy lessons augment these with JSON or JSONL reports containing structured data for automated pipelines.
• Artifacts reside in predictable paths: phases/<phase>/<lesson>/outputs/, making them importable via standard filesystem or HTTP calls.
• Downstream projects can consume these files directly without modifying curriculum source code, enabling composable AI engineering workflows.

Frequently Asked Questions

What is the naming convention for skill artifacts?

Skill artifacts use the prefix skill- followed by a descriptive slug and the .md extension, such as skill-content-classifier-integration.md or skill-rollout-runbook.md. This pattern appears consistently across all phases, from phases/13-tools-and-protocols/01-the-tool-interface/outputs/skill-tool-interface-reviewer.md to phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/skill-end-to-end-safety-gate.md.

Can I use these artifacts in a production application without the curriculum code?

Yes. The Markdown and JSON files are standalone assets. For example, you can copy skill-fairness-criterion.md from phases/18-ethics-safety-alignment/ into your own repository and reference it in documentation, or load rules_report.json into a Node.js service to enforce constitutional rules without importing the original Python implementation from code/main.py.

Do all lessons produce JSON reports, or only specific types?

Only lessons involving quantitative evaluation, rules extraction, or training loops produce JSON artifacts. Implementation-focused lessons may emit only the Markdown skill file, while capstone projects in phases/19-capstone-projects/ typically generate both Markdown skills and accompanying JSON evaluation reports like rules_report.json.

How do I locate the implementation code that generated a specific artifact?

Navigate to the lesson's code/ directory at the same level as the outputs/ folder. For example, phases/19-capstone-projects/87-end-to-end-safety-gate/code/main.py contains the implementation logic that writes to outputs/skill-end-to-end-safety-gate.md. The codebase follows a strict contract where main.py (or main.<lang>) handles artifact generation, tests/ validates correctness, and outputs/ stores the final reusable assets.

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