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

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 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 provides a complete system message for diagnosing ML training failures. You can load this artifact directly into an OpenAI API call:

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 demonstrates this pattern. Run the artifact directly as a Python script:

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 provides a complete entry point for autonomous content review:

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 using npm:

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

Repository Structure and Artifact Location

The 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, 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 line 40
• Consistent location: All artifacts reside in lesson-specific phases/.../outputs/ directories, documented in 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 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, 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.

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