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

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 contains a reusable prompt template:

**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:

# 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, demonstrates the typical structure:

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 shows the FastAPI implementation:

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, 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, 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. Skill artifacts, by contrast, are declarative Markdown files that define capabilities and configurations for agentic systems to invoke, rather than executable scripts themselves.

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