how-to-guide

How to Integrate AI Engineering Outputs and Artifacts Into Your Daily Workflow

August 29, 2026 rohitg00/ai-engineering-from-scratch ↗

The ai-engineering-from-scratch repository treats every lesson's outputs/ folder as a first-class library, shipping deterministic prompts, skill specifications, agent bundles, and MCP server artifacts that you can import directly into production pipelines without additional scaffolding.

The ai-engineering-from-scratch repository by rohitg00 follows a strict "Build/Use" philosophy where theoretical concepts are paired with concrete, version-controlled assets. By learning how to integrate these outputs and artifacts into your daily workflows, you can construct reproducible AI pipelines using battle-tested components that evolve alongside the curriculum.

Where Workflow Artifacts Live

Every lesson stores its deliverables in a predictable outputs/ directory structure. These are regular files (never symlinks) discovered by the static site generator in site/build.js and rendered in the "What This Lesson Ships" panel via site/lesson.html (lines 5188-5205).

The repository organizes four primary asset types:

The CI pipeline validates these assets in site/test_build_artifacts.js (lines 577-618), ensuring that outputs/ directories are regular folders and all files are deterministic and version-controlled.

Architectural Roles in Production Workflows

Each asset type serves a distinct function when integrated into daily engineering pipelines.

Prompt Markdown Files

Prompt markdown provides instruction sets that encode exact context, constraints, and expected JSON schemas. These files contain front-matter metadata and raw prompt text. In your workflow, you load the markdown into a string, strip the front-matter, and feed the content directly to an LLM client.

Skill Specifications

Skill markdown describes reusable capabilities through YAML front-matter (containing name, description, and tags) and an optional reference implementation. Your workflow consumes these by parsing the metadata for discovery and importing the associated Python or TypeScript code from the lesson's code/ folder.

Agent SKILL Bundles

Agent bundles are complete SKILL.md files that define state machines, tool contracts, and guardrails. The learn-agent-skills tutor expects this layout (defined in skills/learn-agent-skills/SKILL.md), allowing you to instantiate agent classes by parsing the YAML specification and passing it to your runtime.

MCP Server Artifacts

MCP server artifacts implement stateless Model Context Protocol servers. These include registry JSON files (server.json) for service discovery and policy-driven dispatch layers. You launch the server via its entry point (e.g., python phases/.../code/main.py) and call it from any MCP-compatible client.

Practical Integration Patterns

Deploy these assets directly into your codebase using the following deterministic patterns.

Loading Prompt Templates in Python

Import prompt markdown and strip the YAML front-matter before sending to your model:

from pathlib import Path
import openai

# Load the prompt markdown shipped with the lesson

prompt_path = Path(
    "phases/00-setup-and-tooling/01-dev-environment/outputs/prompt-env-check.md"
)
prompt_md = prompt_path.read_text()

# Strip the front-matter and send to the model

prompt = prompt_md.split("---", 2)[-1].strip()
response = openai.ChatCompletion.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": prompt}],
)
print(response.choices[0].message.content)

Source: The prompt definition resides in phases/00-setup-and-tooling/01-dev-environment/outputs/prompt-env-check.md.

Consuming Skill Definitions

Parse the YAML front-matter for metadata and import the implementation:

import json
from pathlib import Path
from phases.19-capstone-projects.13-mcp-server-with-registry.code.main import (
    build_readonly_server,
    build_destructive_server,
    Registry,
)

# Load the skill metadata (optional, helpful for discovery)

skill_path = Path(
    "phases/19-capstone-projects/13-mcp-server-with-registry/outputs/skill-mcp-server.md"
)
skill_meta = json.loads(
    "---\n" + skill_path.read_text().split("---", 2)[1]  # grabs the YAML front-matter

)

# Spin up the demo server (stateless, no network)

readonly = build_readonly_server()
destructive = build_destructive_server()
registry = Registry()
registry.register(readonly)
registry.register(destructive)

print("Registered servers:", list(registry.entries))

Source: The skill definition lives in phases/19-capstone-projects/13-mcp-server-with-registry/outputs/skill-mcp-server.md and the implementation is in phases/19-capstone-projects/13-mcp-server-with-registry/code/main.py.

Importing Agent Bundles in TypeScript

Instantiate agents by parsing the SKILL bundle's front-matter:

import { readFileSync } from "fs";
import { Agent } from "./learn-agent-skills/AgentRuntime";

// Load the SKILL bundle (contains the state-machine definition)
const skillText = readFileSync(
  "phases/14-agent-engineering/22-skill-runtime/outputs/release-gate/SKILL.md",
  "utf8"
);
// Parse the markdown front-matter (you can use a YAML parser)
const [, yaml, body] = skillText.split("---");

// Instantiate the agent using the parsed spec
const agent = new Agent(JSON.parse(yaml));
await agent.run(body);

Source: Any outputs/.../SKILL.md follows this convention; the learn-agent-skills tutor uses these contracts as defined in skills/learn-agent-skills/SKILL.md.

Calling MCP Servers from Clients

Execute tool calls through the dispatch layer with proper token validation:

import json, time
from phases.19-capstone-projects.13-mcp-server-with-registry.code.main import (
    request_meta,
    dispatch,
)

# Assume the readonly server from the previous snippet

token = {
    "user": "u42",
    "issuer": "https://auth.internal.example.com",
    "audience": "https://mcp.internal.example.com/readonly",
    "scopes": ["postgres:query:readonly"],
    "expires_at": time.time() + 3600,
}
audit = []

resp = dispatch(
    server=readonly,
    token=token,
    tool="postgres.readonly",
    args={"sql": "SELECT 1"},
    meta=request_meta(),
    audit=audit,
)
print(json.dumps(resp, indent=2))

Source: The dispatch function and supporting types (Token, AuditEntry) are defined in phases/19-capstone-projects/13-mcp-server-with-registry/code/main.py (lines 267-311).

Key Files for Daily Reference

Keep these paths bookmarked for rapid integration:

Summary

  • Every lesson's outputs/ directory functions as a ready-to-use library of deterministic assets.
  • Artifacts include prompt templates, skill specifications, agent bundles (SKILL.md), and MCP server implementations.
  • All files are version-controlled and validated by CI (site/test_build_artifacts.js), ensuring reproducibility.
  • You can import these assets directly—parsing YAML front-matter for metadata and executing Python/TypeScript implementations without additional scaffolding.
  • The repository's static site generator automatically indexes all artifacts, making them discoverable through the "What This Lesson Ships" panel.

Frequently Asked Questions

How do I locate specific artifacts for a lesson?

Navigate to the lesson's folder and check the outputs/ subdirectory. For example, the environment check prompt is at phases/00-setup-and-tooling/01-dev-environment/outputs/prompt-env-check.md. The site generator (site/build.js) automatically populates the "What This Lesson Ships" panel by scanning these directories, so you can also browse the rendered site to discover available files.

Are these artifacts safe to use in production?

Yes. The repository treats these as first-class assets. The CI pipeline in site/test_build_artifacts.js (lines 577-618) validates that all outputs/ entries are regular files (not symlinks) and deterministic. Additionally, MCP server implementations like those in phases/19-capstone-projects/13-mcp-server-with-registry/code/main.py include policy-driven dispatch layers and token-based authentication to ensure safe execution.

How do I extract metadata from skill markdown files?

Skill files contain YAML front-matter between triple-dash delimiters. In Python, split the file content on --- and parse the first block as JSON or YAML. For example: skill_meta = json.loads("---\n" + skill_path.read_text().split("---", 2)[1]). This yields the name, description, and tags fields needed for service discovery.

Can I run MCP servers locally without network dependencies?

Absolutely. The reference implementations in phases/19-capstone-projects/13-mcp-server-with-registry/code/main.py provide build_readonly_server() and build_destructive_server() functions that create stateless, in-memory server instances. These function entirely within your Python process without requiring network ports, making them ideal for unit testing and local development workflows.

Have a question about this repo?

These articles cover the highlights, but your codebase questions are specific. Give your agent direct access to the source. Share this with your agent to get started:

Share the following with your agent to get started:
curl -s "https://instagit.com/install.md"
Works with
Claude Codex Cursor VS Code OpenClaw Any MCP Client

Maintain an open-source project? Get it listed too →