How the AI Engineering from Scratch Curriculum Prepares Students for Production with Capstone Projects

The AI curriculum prepares students for production with capstone projects by moving through 20 phases of increasing complexity, culminating in Phase 19 where learners build and deploy full-stack AI systems using the Build/Use methodology.

The AI Engineering from Scratch repository structures its pedagogy around one explicit goal: ensuring learners can ship production-grade AI systems. By the time students reach the final phases, they have progressed from raw mathematical implementations to full-stack deployment, with the AI curriculum preparing students for production with capstone projects that integrate LLM engineering, agent orchestration, and DevOps practices.

The 20-Phase Architecture Bridging Theory and Production

The curriculum is deliberately organized as a ladder of 20 phases that move learners from pure mathematics to full-stack production systems. Early phases focus on implementing algorithms from scratch with no external libraries, while later phases demand integration with production-grade frameworks like PyTorch, JAX, and the Model-Context Protocol. This progression ensures that by phases/19-capstone-projects/, students possess both theoretical depth and practical implementation skills.

The Build/Use Split: Learning by Implementation

Every lesson follows the Build → Use rhythm documented in the repository's main README.md. First, you implement an algorithm from raw math without external dependencies; then you run the same logic through a production-grade library. This forces a deep understanding of why a framework works rather than merely how to call it. For example, after building a neural network from NumPy, you immediately reconstruct it in PyTorch to compare abstraction layers and performance characteristics.

Artifact-Centric Lessons Build a 500-Tool Portfolio

Each lesson ships a concrete artifact—prompt, skill, agent, or MCP server—stored under the outputs/ directory. By the end of the curriculum, you have a portfolio of approximately 500 reusable tools that you can paste into any AI-enabled workflow. These artifacts serve as the building blocks for capstone projects, allowing students to compose complex systems from battle-tested components they built themselves.

Phase 19 Capstone Projects: Production Integration

Phase 19 (phases/19-capstone-projects/) consolidates everything learned into end-to-end products. The capstone lessons tie together four critical domains of production AI engineering.

LLM Engineering and RAG Systems

Capstones in this domain cover prompt engineering, retrieval-augmented generation (RAG), and function calling. Students reference Phase 11 lessons such as Production LLM App (/phases/11-llm-engineering/13-production-app) to build systems that handle real user traffic and context management.

Tools and Protocols with MCP

Students implement secure, scalable tool interfaces using the Model-Context Protocol. The MCP Server with Registry lesson in Phase 13 (/phases/13-tools-and-protocols/13-mcp-server-with-registry) teaches students to build discoverable tool ecosystems that production agents can consume safely.

Agent Engineering and State Management

Phase 14 lessons like Agent Workbench Capstone (/phases/14-agent-engineering/42-agent-workbench-capstone) instruct students on state-graph orchestration, memory management, and workbench patterns. These capstones produce agents that maintain context across long-running tasks and handle asynchronous interruptions gracefully.

Production Practices and Observability

The curriculum embeds DevOps fundamentals directly into capstone requirements. Students implement Observability with OTel (Lesson 28) and Eval Harness (Lesson 27) pipelines to monitor, trace, and evaluate their systems in production environments. This ensures capstone projects meet industry standards for reliability and maintainability.

Real-World Deployment Patterns

Capstone projects produce runnable code in Python or TypeScript that can be launched locally or as a service. The Production RAG Chatbot (Phase 19, Lesson 08) demonstrates a full-stack deployment pattern:

import { createRAG } from "rag-lib";
import { startServer } from "http";

const rag = createRAG({
  vectorStore: "pinecone",
  llm: "gpt-4o",
  topK: 5,
});

startServer(3000, async (req, res) => {
  const query = await getBody(req);
  const answer = await rag.ask(query);
  res.end(answer);
});

Source: phases/19-capstone-projects/08-production-rag-chatbot/code/ts/README.md

This example combines vector storage, LLM inference, and HTTP API design into a single deployable unit.

Core Agent Architecture for Production

The Speculative-Decoding Inference Server (Lesson 14) and other capstones rely on the REACT-style agent loop taught in Phase 14. The minimal agent loop implementation in phases/14-agent-engineering/01-the-agent-loop/code/agent_loop.py demonstrates the core decision architecture:

def run(query, tools):
    history = [user(query)]
    for step in range(MAX_STEPS):
        msg = llm(history)
        if msg.tool_calls:
            for call in msg.tool_calls:
                result = tools[call.name](**call.args)
                history.append(tool_result(call.id, result))
            continue
        return msg.content
    raise StepLimitExceeded

This pattern appears throughout capstone projects, providing a robust foundation for tool-using agents that can iterate through complex tasks without human intervention.

Implementing Model-Context Protocol Servers

Production capstones require students to expose functionality via standardized protocols. The MCP server skeleton used in several Phase 13 capstones provides a minimal, production-ready template:

from mcp import Server, register_tool

server = Server(host="0.0.0.0", port=8000)

@register_tool
def add(a: int, b: int) -> int:
    return a + b

if __name__ == "__main__":
    server.start()

Source: phases/13-tools-and-protocols/07-building-an-mcp-server/code/server.py

Students extend this scaffold to create registry-enabled servers that authenticate requests and handle concurrent client connections.

CLI Skill Installation for Immediate Validation

The curriculum ships a CLI-style skill suite (scripts/install_skills.py) that can install all generated artifacts. This creates an iterative feedback loop where students immediately test their capstone work in a real environment. After completing a Phase 19 project, running the installer validates that all prompts, skills, and agents function correctly outside the tutorial context.

Summary

• The 20-phase ladder ensures progressive skill acquisition from math to production.
• The Build/Use split forces deep understanding of framework internals before abstraction.
• Phase 19 capstone projects integrate LLM engineering, MCP protocols, agent orchestration, and observability.
• Students produce deployable artifacts in Python and TypeScript, including RAG chatbots and inference servers.
• The scripts/install_skills.py pipeline enables immediate testing of capstone deliverables.

Frequently Asked Questions

What makes the capstone projects production-ready?

The capstone projects in Phase 19 require implementation of observability (OpenTelemetry), evaluation harnesses, secure MCP server registries, and async task handling. Students deploy runnable services like the Speculative-Decoding Inference Server and Production RAG Chatbot that handle HTTP traffic and external API integration, meeting industry standards for monitoring and reliability.

How does the Build/Use methodology prepare students for framework debugging?

By forcing students to first implement algorithms from raw math without libraries, the curriculum ensures they understand the underlying mechanics of matrix operations, gradient descent, and attention mechanisms. When they later encounter bugs in PyTorch or JAX implementations, they can trace errors to the mathematical source rather than treating frameworks as black boxes.

What is the structure of Phase 19 capstone projects?

Phase 19 (phases/19-capstone-projects/) contains end-to-end products that consolidate skills from previous phases. Each capstone specifies concrete deliverables: a deployed service (Python or TypeScript), an MCP tool registry, an agent workbench with state management, and an observability dashboard. Examples include Lesson 08's Production RAG Chatbot and Lesson 14's Speculative-Decoding Inference Server.

How does the skill installer help validate capstone work?

The scripts/install_skills.py utility installs every artifact generated across the 20 phases into a live environment. After completing a capstone, students run this installer to verify that their prompts, skills, and agents function correctly when imported into external projects. This prevents "tutorial isolation" and confirms that capstone deliverables are genuinely reusable production components.

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