← Back to Main

Learn AI Full curriculum outline

Concepts

Foundations → deeper theory

What is AI (and what it is not)
Classical ML literacy
Tokenization
Self-attention
Embeddings and similarity
Prompt engineering fundamentals
Structured outputs
RAG building blocks
Agents and the ReAct loop
Evals fundamentals
Serving and streaming
Networking for AI apps
LLM project lifecycle
Multimodal basics
Privacy and data for AI apps
Open-weight models vs closed APIs

Advanced Concepts

Scaling laws and compute
Fine-tuning with LoRA and QLoRA
Alignment basics — RLHF and DPO
Mixture of Experts (MoE)
Context engineering
Reasoning and test-time compute
Multi-agent orchestration
Guardrails and safety systems

Tools

Everyday stacks → production tooling

LangGraph and LangChain patterns
Hugging Face
Ollama
Model Context Protocol (MCP)
LlamaIndex
OpenAI and Anthropic APIs
Chroma
Weights & Biases

Advanced Key Tech

Ray
Triton Inference Server
Kafka for evented AI
OpenTelemetry for LLMs
TensorRT-LLM and SGLang
MLflow for LLMOps

Data & inference

Retrieval data plane + serving

Data & Databases for AI

Vector databases — what, why, and how
Choosing vector stores — Pinecone, Weaviate, Chroma, pgvector
Postgres and pgvector
Redis for AI caching
Chunking and metadata
Hybrid search and rerankers

vLLM
KV-cache, prefill, and decode
Continuous batching
Quantization for inference
Speculative decoding
Cost and latency routing

Guided path

Projects · foundations → build → agents → production

Foundations

How this course works
Python, tooling, and compute options
API keys, budgets, and responsible use
Rubric: tests, eval JSON, and README

What happened in AI (till now)

Symbolic AI → why rules hit a wall
Classical ML era
Deep learning boom
Attention → Transformer → GPT lineage
Generative AI landscape
Open-weight vs closed API
Jobs: AI eng, ML eng, research, FDE, PM

Data splits and leakage
Loss, gradients, and overfitting
Embeddings before LLMs
Autograd intuition
PyTorch training loop

Build an LLM from scratch

Tokenization and BPE
Next-token prediction
MLP language model
Self-attention
Tiny GPT / mini-LLM end-to-end
Sampling (temperature, top-k/p)
Pretrain vs SFT vs preference (map only)
Why your tiny LLM ≠ ChatGPT

Generative AI practice

Talk to models in the real world

Chat APIs and message roles
Structured output
Prompt versioning
Multimodal in → text
Code assist loops

Embeddings and similarity
Chunking
Vector DB
Hybrid search
Rerank / rewrite
Citations and failures

Build & serve your SLM

When SLM/FT beats RAG or prompting
Dataset curation and licenses
LoRA / QLoRA fine-tune
Eval vs base / teacher
Serve your SLM
Quantization tradeoffs

Agents & agentic systems

Build real AI agents

LLM vs agent; loops; stop conditions
Tools (schema, validation, side effects)
Planning vs reactive
Memory
Human-in-the-loop
Trace and debug trajectories
Framework packaging

Skills, MCP, context engineering

Skill vs tool vs prompt
Author skills
Dynamic skill loading
MCP servers and clients
Context budgets
Coding-agent skill patterns

Agentic workflows & multi-agent

Workflow patterns
Shared state and handoffs
Agentic RAG
Long-running / checkpoint / resume
Failure isolation
Harness thinking

Production + how companies actually do it

Evals, guardrails, safety

Offline vs online evals
LLM-as-judge
Component vs E2E
Injection / jailbreaks
Guardrails
Canaries

Deploy, cost, latency, observability

API + streaming
Cost accounting
Caching and latency
Tracing tool/LLM spans
Retries, rate limits, idempotency
Runbook

How real companies use AI

Netflix — in-house LLM serving
Uber — agent platform, MCP, gateway
Meta — LLM-scale training literacy
Stripe — coding agents / harness
Shopify — production merchant agent
Airbnb — verify-heavy workflows
NVIDIA — agent toolkits and eval/obs
Google — agentic training / RL direction

AI system design

Build vs buy
UX of uncertainty, citations, feedback
Data flywheels
Privacy / retention sketch
Capstone proposal

Frontier + capstone

What’s coming + staying current

Reasoning models / test-time compute
Multimodal agents
On-device / small models
Synthetic data loops
Safety, regulation, dual-use
Personal radar

Capstone requirements and pick-two
Architecture and eval plan
Build and harden
Write-up and demo

⌕⌘K

FoundationsBuild an LLM from scratch

Foundations

Build an LLM from scratch

Karpathy-depth, course-paced: tokenize, predict, attend, and train your own mini-LLM — then state honest limits vs frontier systems.

Milestone Your own mini-LLM in the portfolio (train script, samples, README).

Lessons in this module

1. 65 minTokenization and BPEProject: Train tiny tokenizerOpen
2. 55 minNext-token predictionProject: Bigram LMOpen
3. 60 minMLP language modelProject: Train + sampleOpen
4. 70 minSelf-attentionProject: Implement attention blockOpen
5. 90 minTiny GPT / mini-LLM end-to-endProject: Train on CPU/Colab; generate textOpen
6. 55 minSampling (temperature, top-k/p)Project: Ablation tableOpen
7. 45 minPretrain vs SFT vs preference (map only)Project: Lifecycle diagramOpen
8. 45 minWhy your tiny LLM ≠ ChatGPTProject: Honest limits write-upOpen

PreviousPyTorch training loop NextTokenization and BPE

ShipAI curriculum

A structured path from foundations to production agents — lessons, projects, and milestones in one course. Free forever.

Reading progress

On this page

Overview
Lessons
Tokenization and BPE
Next-token prediction
MLP language model
Self-attention
Tiny GPT / mini-LLM end-to-end
Sampling (temperature, top-k/p)
Pretrain vs SFT vs preference (map only)
Why your tiny LLM ≠ ChatGPT