# What Types of Reusable Artifacts Does AI Engineering From Scratch Produce?

> Discover the four reusable artifacts AI Engineering From Scratch produces prompts skills agents and MCP servers as drop-in modules for your AI workflows

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: architecture
- Published: 2026-06-22

---

**The AI Engineering From Scratch curriculum produces four concrete reusable artifacts: prompts, skills, agents, and MCP servers, each designed as drop-in modules for real-world AI workflows.**

The **AI Engineering From Scratch** repository by RohitG00 is structured around a practical philosophy: every lesson must ship a concrete deliverable. Instead of abstract theory, learners generate **reusable artifacts** that can be copied directly into production environments. According to the repository's README, these artifacts fall into four distinct categories designed for immediate integration with LLM-powered systems.

## The Four Categories of Reusable Artifacts

Every lesson in the curriculum ends with a concrete, reusable artifact that can be dropped into a real-world workflow. According to the repository's README, the four artifact categories are:

### Prompts (Plain-Text Templates)

**Prompts** are plain-text or templated instructions stored as Markdown files that can be pasted into any LLM-powered assistant to solve a narrow task. These artifacts typically live in `outputs/prompts/…/*.md`.

For example, [`outputs/prompts/example-prompt.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/outputs/prompts/example-prompt.md) contains a reusable prompt template:

```markdown
**Task:** Summarize the key ideas of the paper “Attention Is All You Need”.

**Prompt:**

```

Summarize the core contributions of the paper “Attention Is All You Need” in under 150 words. Highlight the problem it solves, the main technical innovation, and its impact on downstream models.

```

```

### Skills (Self-Contained Skill Modules)

**Skills** are small, self-contained modules formatted for Claude, Cursor, Codex, and other agentic systems. These files allow agents to invoke specific capabilities directly. You will find these artifacts in paths like `phases/…/outputs/skill‑*.md`.

A concrete example is the **End‑to‑End Safety Gate** skill located at [`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):

```markdown

# Skill: End‑to‑End Safety Gate

**Description:** Runs the full safety‑gate pipeline: loads the jailbreak taxonomy, runs the prompt‑injection detector, aggregates per‑category metrics, and emits `gate_trace.json`.

**Inputs:** `taxonomy.json`, `detector_report.json`  
**Outputs:** `gate_trace.json` (trace of safety decisions)  

**Command:** `python3 main.py`

```

### Agents (Full Autonomous Implementations)

**Agents** are complete implementations in Python or TypeScript that embody autonomous worker loops. These artifacts reside in `phases/…/code/agent_*.py` and can be run as standalone workers.

The core agent loop from Phase 14, found in [`phases/14-agent-engineering/01-agent-loop/code/agent_loop.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/01-agent-loop/code/agent_loop.py), demonstrates the typical structure:

```python
def run(query, tools):
    history = [user(query)]
    for step in range(MAX_STEPS):
        msg = llm(history)
        if msg.tool_calls:
            # invoke tools, append results, continue

            …
        else:
            break
    return msg.content

```

### MCP Servers (Model Control Protocol Implementations)

**MCP servers** are minimal-API servers implementing the Model Control Protocol, allowing any MCP-compatible client to call the underlying models. These artifacts are stored in `phases/…/code/mcp_server_*.py`.

A minimal MCP server stub from [`phases/13-tools-and-protocols/01-mcp-server/code/server.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/01-mcp-server/code/server.py) shows the FastAPI implementation:

```python
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/mcp/v1/chat")
async def chat(req: Request):
    payload = await req.json()
    # Forward to underlying LLM, return MCP‑formatted response

    …
    return {"choices": [{"message": {"role": "assistant", "content": answer}}]}

```

## Why These Artifacts Are Production-Ready

These artifacts are deliberately designed as **"drop-in"** modules. You can copy the files into another project and start using them immediately, without any extra scaffolding. This approach creates a hands-on portfolio: after completing the lessons, you own a library of prompts, skills, agents, and MCP servers ready for reuse in your own production workflows.

## Summary

- **Prompts** are templated Markdown files stored in `outputs/prompts/` that provide ready-to-use LLM instructions.
- **Skills** are self-contained module definitions located in `phases/…/outputs/skill‑*.md` that integrate with Claude, Cursor, and Codex.
- **Agents** are full Python implementations in `phases/…/code/agent_*.py` that run as autonomous workers.
- **MCP Servers** are minimal API servers in `phases/…/code/mcp_server_*.py` that implement the Model Control Protocol for client compatibility.

## Frequently Asked Questions

### What makes these artifacts "reusable" compared to tutorial code?

Unlike typical tutorial snippets, these artifacts are designed as standalone modules with defined inputs and outputs. According to the repository's README, each lesson ships a concrete deliverable that requires no additional scaffolding to deploy, making them immediately portable to production environments.

### Where are the skill artifacts located in the repository?

Skill artifacts are stored in `phases/…/outputs/skill‑*.md` throughout the repository structure. A specific 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 skill for Claude and other agentic systems.

### Can I use these MCP servers with any LLM client?

Yes, the **MCP servers** implement the Model Control Protocol (MCP), which is a standardized interface. As shown in [`phases/13-tools-and-protocols/01-mcp-server/code/server.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/01-mcp-server/code/server.py), these FastAPI-based servers expose endpoints like `/mcp/v1/chat` that any MCP-compatible client can invoke, regardless of the underlying model provider.

### How do the agent artifacts differ from the skill files?

**Agent** artifacts are full implementations containing executable Python code that runs the autonomous loop, such as the `run()` function in [`phases/14-agent-engineering/01-agent-loop/code/agent_loop.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/01-agent-loop/code/agent_loop.py). **Skill** artifacts, by contrast, are declarative Markdown files that define capabilities and configurations for agentic systems to invoke, rather than executable scripts themselves.