Teaching Philosophy: From Complex to Clear
My approach to teaching complex AI concepts, refined through years in the classroom and now applied to cutting-edge technology.
Start with the 'why' - understand the problem before diving into solutions
Break complex systems into manageable, logical components
Learn by building - every concept is paired with hands-on implementation
Connect new concepts to existing knowledge you already have
Practice makes permanent - repetition builds understanding
Name where it's genuinely hard — confusion is part of the path, not a detour
Learning Paths
Structured learning journeys that take you from beginner to expert. Each path is designed with clear progression and hands-on projects.
AI Systems: An Introduction
A beginner-friendly introduction to AI Systems, covering workflow engines, AI agents, LLMs, and MCP servers. Learn how these technologies work together to solve real-world problems.
- Understand what AI Systems are and their core components
- Visualize how workflow engines, agents, LLMs, and MCP servers work together
- Identify real-world applications for small businesses and personal use
- Build a simple but functional AI System using Python and the MCP SDK
MCP Server Fundamentals
Build your first Model Context Protocol server from scratch. Learn the core concepts, architecture patterns, and best practices.
You'll Learn:
Outcomes:
- •Understand MCP protocol fundamentals
- •Build a basic MCP server from scratch
- •Implement resource and tool providers
- +1 more outcomes
Agentic AI Workflows
Design intelligent systems that can reason, plan, and execute complex tasks autonomously with human oversight.
You'll Learn:
Prerequisites:
Outcomes:
- •Design agent architectures for complex tasks
- •Implement planning and reasoning systems
- •Build human-in-the-loop workflows
- +1 more outcomes
Production AI Systems
Deploy, monitor, and scale AI systems in production. Learn enterprise patterns for reliable AI applications.
You'll Learn:
Prerequisites:
Outcomes:
- •Deploy AI systems to production environments
- •Implement comprehensive monitoring and observability
- •Design systems that scale with demand
- +1 more outcomes
12-Factor Agent Development
Master the patterns and principles for building reliable, production-ready LLM applications based on Dex Horthy's 12-Factor Agent framework.
You'll Learn:
Prerequisites:
Outcomes:
- •Understand agents as reliable software systems, not magical AI
- •Master JSON-based control flow and stateless agent design
- •Build micro-agents that do one thing well
- +2 more outcomes
Mastering Claude Code: From Terminal to Custom Integrations
Learn to leverage Claude Code's unopinionated approach to AI-assisted development. From understanding the evolution of programming tools to building custom integrations with the SDK.
You'll Learn:
Prerequisites:
Outcomes:
- •Understand the evolution of programming tools and where AI fits
- •Master Claude Code's terminal, IDE, and GitHub integrations
- •Implement advanced workflows like TDD and parallel sessions
- +2 more outcomes
Building Intelligent AI Agents with Memory
Master the architecture and implementation of memory systems for AI agents. Learn 10+ memory types, management patterns, and production deployment strategies inspired by neuroscience.
You'll Learn:
Prerequisites:
Outcomes:
- •Understand 10+ types of agent memory and their use cases
- •Build comprehensive memory management systems
- •Implement neuroscience-inspired memory patterns
- +2 more outcomes
Data Structures & Algorithms: Foundations
Build genuine fluency in the data structures and algorithm patterns that underpin everyday engineering. Python-first, pattern-by-pattern, grounded in the kind of problems a working AI engineer actually reasons about — and why each tool exists.
You'll Learn:
Outcomes:
- •Reach for the right Python tool — Counter, deque, heapq, bisect — and know when each is the wrong choice
- •Reason about time and space complexity, and explain the trade-offs out loud
- •Recognize the dominant patterns: hashing, two pointers, sliding window, binary search
- +2 more outcomes
Data Structures & Algorithms: Advanced
The harder algorithmic techniques — heaps, intervals, backtracking, dynamic programming, and greedy — plus a capstone on decomposing and solving genuinely hard problems under real constraints.
You'll Learn:
Prerequisites:
Outcomes:
- •Use heaps for top-K, merge-K, and running-median problems
- •Sweep and merge intervals cleanly
- •Structure backtracking for permutations, subsets, and search
- +3 more outcomes
System Design for Engineers
Reason about open-ended system design by walking through systems actually built — RAG, async job pipelines, streaming chat, rate limiters, real-time messaging, and orchestration engines — and the trade-offs that separate a workable design from a brittle one.
You'll Learn:
Outcomes:
- •Structure any design: clarify, estimate, define the API, model the data, then scale
- •Design a document Q&A / RAG system end to end, from chunking to streaming
- •Design an async job-processing pipeline with idempotency, retries, and dead-letter handling
- +2 more outcomes
Concepts & Patterns
Core concepts and patterns every engineer should understand — what each one is, how it works, and, just as important, when not to reach for it.
Big-O & Complexity
A mental model for reasoning about how an algorithm's time and memory usage scale with input size — the foundation of every performance conversation in engineering.
Related Concepts:
Python Speed Kit
The standard-library tools that replace hand-rolled data structures: Counter, defaultdict, deque, heapq, bisect, and functools.cache — what each does, when to reach for it, and when not to.
Related Concepts:
Hashing & Frequency Maps
The pattern behind a huge share of array and string problems: use a hash map to trade memory for speed, turning O(n²) searches into O(n) single-pass solutions.
Related Concepts:
Token Bucket Rate Limiting
A rate-limiting algorithm that allows bursts up to a capacity cap while enforcing an average throughput ceiling — the pattern used in production APIs and my workflow-engine-rs implementation.
Related Concepts:
DAG Orchestration
Directed Acyclic Graphs (DAGs) model task dependencies so an orchestrator can run independent tasks in parallel and detect illegal cycles before execution — the backbone of workflow engines and job pipelines.
Related Concepts:
Hybrid Retrieval
Combining BM25 keyword search with dense vector similarity to surface documents that match both the vocabulary and the meaning of a query — the retrieval architecture at the core of my rag-engine-rs project.
Related Concepts:
Why Learn Agentic AI?
The Future is Agentic
AI systems are evolving from simple chatbots to intelligent agents that can plan, reason, and execute complex tasks. Companies are racing to build these systems, and demand for engineers who understand agentic architectures is exploding.
Real production agentic systems need more than prompts — they need orchestration, memory, retrieval, and reliability. This curriculum teaches the patterns that hold together in production, not just in demos.
Competitive Advantage
While most developers are still learning basic prompt engineering, you'll master the architectural patterns that power next-generation AI applications. This knowledge translates directly to higher-impact roles and better compensation.
My teaching approach ensures you don't just follow tutorials - you understand the underlying principles so you can architect your own solutions.