# What Reusable Artifacts (Prompts, Skills, Agents, and MCP Servers) Are Generated per Lesson

> Discover reusable artifacts like prompts, skills, agents, and MCP servers generated per lesson in AI Engineering from Scratch. Deploy them immediately for real-world applications.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: internals
- Published: 2026-07-31

---

**Every lesson in the AI Engineering from Scratch curriculum ships production-ready reusable artifacts—including prompts, skills, agents, and MCP servers—to the lesson's `outputs/` directory, enabling immediate cross-lesson reuse and real-world deployment.**

The rohitg00/ai-engineering-from-scratch repository implements a "Ship" pedagogy where each lesson culminates in concrete, version-controlled deliverables. These reusable artifacts generated per lesson follow standardized schemas—**SKILL.md** for capabilities and **Prompt.md** for templates—making them discoverable and importable by downstream lessons without additional coding.

## Artifact Types and File Patterns

Each lesson’s `outputs/` subdirectory contains one or more files that capture the concrete artifact produced. The curriculum recognizes five primary artifact categories, each with distinct naming conventions and schemas.

### Prompt Templates

**Prompt artifacts** use the file pattern `prompt-*.md` or `prompt-*.json` and contain markdown-formatted prompt templates together with usage notes. These files are ready to be fed directly to an LLM API.

For example, [`phases/02-ml-fundamentals/15-time-series/outputs/prompt-time-series-advisor.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/02-ml-fundamentals/15-time-series/outputs/prompt-time-series-advisor.md) provides a structured template for time-series analysis queries. Similarly, [`phases/02-ml-fundamentals/01-what-is-machine-learning/outputs/prompt-ml-problem-framer.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/02-ml-fundamentals/01-what-is-machine-learning/outputs/prompt-ml-problem-framer.md) offers a reusable prompt that frames machine-learning problems for LLM consumption.

### Capability Skills

**Skill artifacts** follow the `skill-*.md` pattern and represent self-contained descriptions of reusable capabilities. These files adhere to the **SKILL.md** specification and can be imported by any downstream lesson or external project.

An example is [`phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/skill-end-to-end-safety-gate.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/skill-end-to-end-safety-gate.md), which defines a safety-gate wrapping an LLM with a classifier and human-approval flow. Another example, [`phases/12-multimodal-ai/25-multimodal-agents-computer-use/outputs/skill-multimodal-agent-designer.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/12-multimodal-ai/25-multimodal-agents-computer-use/outputs/skill-multimodal-agent-designer.md), describes a multimodal agent combining vision, audio, and text tools.

### Agent Definitions

**Agent artifacts** are specialized skill files focused on autonomous runtime behavior. These use the same `skill-*.md` schema but include tool sets, state-graph definitions, and runtime configuration.

The file [`phases/19-capstone-projects/03-realtime-voice-assistant/outputs/skill-voice-agent.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/03-realtime-voice-assistant/outputs/skill-voice-agent.md) defines a real-time voice-assistant agent, complete with its state graph and tool integrations. Because agents conform to the skill schema, they remain discoverable by other lessons through the same import mechanisms.

### MCP Servers

**MCP Server artifacts** represent full Model Context Protocol server definitions, including tools, resources, prompts, and deployment instructions. These files use patterns like [`skill-mcp-server.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/skill-mcp-server.md) and expose real functionality via the standardized protocol.

The curriculum treats MCP servers as the primary mechanism for exposing production-grade tools. For instance, [`phases/19-capstone-projects/13-mcp-server-with-registry/outputs/skill-mcp-server.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/13-mcp-server-with-registry/outputs/skill-mcp-server.md) contains a complete deployment blueprint using FastMCP or the `@modelcontextprotocol/sdk`, alongside security configurations for OAuth 2.1 and OPA policies.

### Evaluation Reports and Traces

**JSON artifacts** capture structured results from evaluations, audits, or telemetry. Files like [`gate_trace.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/gate_trace.json) or [`classifier_report.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/classifier_report.json) provide machine-readable audit trails that downstream lessons can programmatically ingest.

The file [`phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/gate_trace.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/gate_trace.json) stores a structured trace of the safety-gate’s decision pipeline, allowing subsequent lessons to analyze decision patterns or feed results into compliance dashboards.

## Consuming Artifacts Across Lessons

Downstream lessons import previous artifacts via simple markdown links like `[[skill-mcp-server.md]]`, which the build pipeline resolves to concrete file paths. The repository provides explicit patterns for loading each artifact type.

### Loading a Prompt

You can load and execute a prompt artifact directly using standard file I/O:

```python

# Example: Use a prompt generated by Lesson 02-linear-regression

from pathlib import Path

prompt_path = Path(
    "phases/02-ml-fundamentals/02-linear-regression/outputs/prompt-ml-problem-framer.md"
)
prompt_template = prompt_path.read_text()

# Pass the prompt to any LLM API (e.g., OpenAI)

response = openai.ChatCompletion.create(
    model="gpt-4o",
    messages=[{"role": "system", "content": prompt_template}],
)
print(response.choices[0].message.content)

```

### Running an MCP Server Skill

MCP server artifacts include fenced bash blocks containing deployment commands. You can launch the server directly from the skill file:

```bash

# The skill-mcp-server.md file contains a FastMCP deployment script.

# Launch the server with the provided command:

bash phases/19-capstone-projects/13-mcp-server-with-registry/outputs/skill-mcp-server.md

```

The repository’s CI tests verify that these commands start compliant MCP servers, ensuring the artifact functions immediately upon generation.

### Invoking an Agent Skill

For TypeScript environments, the artifacts integrate with the Model Context Protocol SDK:

```typescript
import { loadSkill } from "@modelcontextprotocol/sdk";

// Load the voice-agent skill generated by the capstone lesson
const skillPath = "phases/19-capstone-projects/03-realtime-voice-assistant/outputs/skill-voice-agent.md";
const voiceAgent = await loadSkill(skillPath);

// Use the agent to run a conversation
const result = await voiceAgent.run({
  user: "What’s the weather like today?",
});
console.log(result);

```

## Architectural Standards for Reusability

The curriculum enforces strict conventions to ensure every artifact remains portable and discoverable across the 19 learning phases.

### Standardized Metadata

Every artifact includes a standardized header comment citing the originating lesson and follows either the **SKILL.md** or **Prompt.md** schema. This consistency ensures the site generator ([`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js)) can parse artifacts across different programming languages and frameworks.

### Traceability and Version Control

All artifacts are version-controlled and discoverable via the `outputs/` folder. The curriculum’s site generator automatically extracts each artifact’s title and link from the lesson’s [`docs/en.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/docs/en.md) front-matter, exposing them in the UI for immediate reuse.

### Production-Ready Deployment

MCP server artifacts ship with deployment blueprints that include security hardening. These specifications cover FastMCP implementations, OAuth 2.1 configurations, and OPA (Open Policy Agent) policies, allowing the artifact to be dropped into production environments without modification.

## Summary

- Every lesson in rohitg00/ai-engineering-from-scratch produces version-controlled artifacts in an `outputs/` subdirectory.
- **Prompts** (`prompt-*.md`) provide ready-to-use LLM templates, while **Skills** (`skill-*.md`) define reusable capabilities following the SKILL.md specification.
- **Agents** and **MCP Servers** use the skill schema to expose state-graph definitions and production-grade tool protocols, complete with deployment blueprints.
- **JSON reports** offer machine-readable traces for audit and evaluation pipelines.
- The build pipeline ([`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js)) automatically exposes these artifacts through the curriculum UI, and downstream lessons import them via markdown link syntax.

## Frequently Asked Questions

### How do I import an artifact from a previous lesson into my current project?

Reference the artifact using the markdown link syntax `[[artifact-filename.md]]` in your lesson’s documentation or source code. The curriculum’s build pipeline resolves this link to the concrete file path within the `outputs/` directory. For programmatic access, use standard file I/O or the `@modelcontextprotocol/sdk` loader for skill artifacts.

### What distinguishes a Skill from an Agent in the curriculum’s artifact model?

A **Skill** represents a reusable capability—such as an MCP server or safety gate—defined in a `skill-*.md` file per the SKILL.md specification. An **Agent** is a specialized skill that additionally includes autonomous runtime behavior, state-graph definitions, and tool orchestration logic. Both use the same file schema, but agents explicitly model conversational or sequential state management.

### Are the MCP servers generated by lessons production-ready immediately?

Yes. According to the source code, MCP server artifacts include complete deployment blueprints using FastMCP or the official Model Context Protocol SDK, alongside security configurations for OAuth 2.1 and OPA policies. The repository’s CI pipeline verifies that the provided bash commands launch compliant MCP servers, ensuring the artifact requires no additional coding for deployment.

### Where does the curriculum store evaluation traces and audit logs?

Evaluation artifacts are stored as JSON files in the same `outputs/` directory as skills and prompts. For example, [`phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/gate_trace.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/87-end-to-end-safety-gate/outputs/gate_trace.json) contains structured decision traces from the safety-gate pipeline. These files follow predictable naming patterns like `*trace.json` or `*report.json` and are designed for programmatic consumption by downstream lessons or external compliance tooling.