# AI Engineering from Scratch Reusable Artifacts: Prompts, Skills, Agents, and MCP Servers

> Discover reusable artifacts in AI Engineering from Scratch: Prompts, Skills, Agents, and MCP Servers. Get production-ready code with every lesson.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: deep-dive
- Published: 2026-08-28

---

**AI Engineering from Scratch produces four categories of reusable artifacts—Prompts, Skills, Agents, and MCP Servers—shipping concrete, production-ready code in every lesson's `outputs/` directory.**

The rohitg00/ai-engineering-from-scratch curriculum is architected around a "build it, use it" philosophy where theoretical concepts materialize as immediately deployable code. Unlike traditional tutorials that leave learners with fragmented notes, this repository guarantees that every lesson generates **reusable artifacts** stored in predictable `outputs/` folders, enabling direct integration into production ML pipelines.

## The Four Categories of Reusable Artifacts

According to the repository's [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) at line 40, the curriculum explicitly defines four artifact types that learners can extract and deploy: "Every lesson ships a reusable artifact: a prompt, a skill, an agent, an MCP server."

### Prompts

**Prompts** are ready-to-use text templates—often written in Markdown—that can be copied directly into language model API calls or prompt engineering workflows. These artifacts live in `phases/.../outputs/*.md` files and contain system instructions, few-shot examples, and formatting specifications.

For example, the debugging prompt at [`phases/00-setup-and-tooling/12-debugging-and-profiling/outputs/prompt-debug-ai-code.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/00-setup-and-tooling/12-debugging-and-profiling/outputs/prompt-debug-ai-code.md) provides a complete system message for diagnosing ML training failures. You can load this artifact directly into an OpenAI API call:

```python
import openai

# Load the prompt artifact from the outputs folder

with open("phases/00-setup-and-tooling/12-debugging-and-profiling/outputs/prompt-debug-ai-code.md") as f:
    system_prompt = f.read()

response = openai.ChatCompletion.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": "My loss is NaN after epoch 2"}
    ],
)

```

### Skills

**Skills** are self-contained pieces of logic—usually scripts, configurations, or small libraries—that implement reusable capabilities such as samplers, evaluation metrics, or data-pipeline components. These appear as `phases/.../outputs/skill-*.md` files and contain executable code blocks.

The gradient accumulation skill at [`phases/19-capstone-projects/46-gradient-accumulation/outputs/skill-gradient-accumulation.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/19-capstone-projects/46-gradient-accumulation/outputs/skill-gradient-accumulation.md) demonstrates this pattern. Run the artifact directly as a Python script:

```bash
python gradient_accumulator.py --batch-size 32 --max-steps 1000

```

### Agents

**Agents** are minimal autonomous programs that demonstrate specific "agentic" patterns including tool-calling, state-machine coordination, or multi-session handoff. Unlike simple scripts, these are functional Python, TypeScript, or Julia programs stored alongside skill documentation in `phases/.../outputs/skill-*.md` files.

The reviewer agent at [`phases/14-agent-engineering/39-reviewer-agent/outputs/skill-reviewer-agent.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/14-agent-engineering/39-reviewer-agent/outputs/skill-reviewer-agent.md) provides a complete entry point for autonomous content review:

```bash
python -m reviewer_agent --task "summarize the following article"

```

### MCP Servers

**MCP Servers** are Model-Context-Protocol implementations that enable structured, versioned data exchange between language models and downstream tools. These artifacts follow the same `outputs/skill-*.md` naming convention but contain server startup configurations and protocol handlers.

Start the knowledge-base server from [`phases/13-tools-and-protocols/06-mcp-fundamentals/outputs/skill-mcp-fundamentals.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/06-mcp-fundamentals/outputs/skill-mcp-fundamentals.md) using npm:

```bash
npm run start:mcp-server -- --port 8080

```

## Repository Structure and Artifact Location

The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file at lines 24-25 documents the repository layout, emphasizing that each lesson's `outputs/` directory contains the generated artifact. This predictable structure—`phases/{phase-number}-{topic}/{lesson-number}-{name}/outputs/`—allows automated tooling to extract and index all reusable components systematically.

As documented in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md), the `outputs/` folder serves as the canonical location for lesson deliverables, separating educational content (in lesson READMEs) from deployable code.

## How to Consume Artifacts in Your Projects

Integrating these **reusable artifacts** into your own codebase follows a consistent pattern across all four types:

1. **Locate** the artifact in the corresponding `outputs/` subdirectory using the repository's phase-based organization
2. **Copy** the Markdown content (for prompts) or extract the code blocks (for skills, agents, and MCP servers)
3. **Adapt** any hardcoded paths or configuration variables to match your environment
4. **Deploy** using the entry points documented in each artifact's header comments

For prompt artifacts, direct file reading suffices. For executable artifacts like agents and MCP servers, ensure you install the dependencies listed in the artifact's requirements section before running the provided CLI commands.

## Summary

- **Four artifact types**: The curriculum produces Prompts, Skills, Agents, and MCP Servers, as declared in [`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md) line 40
- **Consistent location**: All artifacts reside in lesson-specific `phases/.../outputs/` directories, documented in [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) lines 24-25
- **Production ready**: Each artifact is immediately runnable, from Python scripts for gradient accumulation to Node.js MCP servers
- **Multi-language support**: Artifacts span Python, TypeScript, Julia, and Bash depending on the lesson's engineering focus
- **Copy-paste integration**: The repository structure supports direct extraction of code into external projects without modification

## Frequently Asked Questions

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

Each lesson stores its deliverables in an `outputs/` subdirectory within the phase folder, following the pattern `phases/{phase}-{topic}/{lesson}-{name}/outputs/`. The [`AGENTS.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/AGENTS.md) file at lines 24-25 explicitly documents this layout, separating artifacts from educational content.

### What is the difference between a Skill artifact and an Agent artifact?

**Skills** are self-contained utilities—such as evaluation metrics or data pipelines—that execute specific functions without autonomy. **Agents** demonstrate "agentic" patterns like tool-calling and state management, implementing autonomous decision loops rather than single-shot computations.

### How do I run an MCP Server artifact from the curriculum?

MCP Server artifacts include startup commands in their `outputs/skill-*.md` documentation. For Node.js implementations like the knowledge-base server at [`phases/13-tools-and-protocols/06-mcp-fundamentals/outputs/skill-mcp-fundamentals.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/phases/13-tools-and-protocols/06-mcp-fundamentals/outputs/skill-mcp-fundamentals.md), execute `npm run start:mcp-server -- --port 8080` after installing dependencies.

### Can I modify and redistribute these artifacts?

The raw source analysis does not specify licensing terms. However, the repository's design philosophy treats these as templates intended for integration into your own projects. Review the repository's LICENSE file at the root level for specific redistribution rights.