Curated online resources organized by unit · Free and low-cost resources prioritized
How to Use This Guide
This guide provides curated resources for each of the three course units. Resources are grouped by topic and marked with a cost indicator. Nearly everything below is free or freely auditable — where a resource has a paid tier, the free portion already covers what's relevant to this course, and that's noted explicitly.
A note on O'Reilly titles: UW–Madison students have free access to the full O'Reilly online learning platform (books, videos, and live courses from O'Reilly, Packt, Manning, and ~200 other publishers) via the library's subscription. Entries below marked Free (UW–Madison, via library) link through ezproxy.library.wisc.edu, which will prompt for your NetID and land you directly on that title. General portal: digital.library.wisc.edu/1711.web/oreilly (opens in new tab).
Students do not need to complete entire courses listed here. The annotations in the "What Students Will Learn" column indicate which parts are most directly relevant to the course. Treat these as a menu, not a mandatory checklist.
Unit 1 — AI-Assisted Software Development Weeks 1–5
The resources below cover setting up an effective AI-assisted development workflow, frontend basics (TypeScript + p5.js for Project 1), Git/GitLab, GitLab CI/CD pipelines, Docker, backend REST APIs with FastAPI, relational databases, and authentication — everything needed for Lectures 1–9 and Projects 1–2.
This class’s own library of Claude Code skills and rules, which every student can use and contribute to. Its README explains how to install a skill or rule, how to contribute one through a merge request, and how to use the repository responsibly. Sign in to GitLab with your NetID to view it.
Building, configuring, and sharing reusable markdown instructions (Skills) for Claude Code — a deeper option for students who want to customize their workflow beyond the basics.
Using and creating sub-agents in Claude Code for task delegation — relevant once projects get large enough that one long agent session stops being the best tool.
Anthropic's own framework for collaborating with AI systems effectively, efficiently, ethically, and safely — a good conceptual complement to the hands-on Claude Code courses above.
Interactive, in-browser tool that draws the commit graph live as you type Git commands — a fast, hands-on way to build real intuition for branching, merging, and rebasing (including the difference between them).
Gamified, level-based interactive tutorial for practicing branching, merging, and rebasing through visual challenges — a popular, more structured complement to Visualizing Git above.
Official GitLab learning path covering .gitlab-ci.yml syntax, stages, jobs, runners, and variables — the core pipeline concepts. Also required pre-class reading for Lecture 14, which is the first lecture where students write a new pipeline stage rather than just consuming one.
Required pre-class reading for Lecture 2. Covers the setup()/draw() loop, the canvas coordinate system, and basic drawing/color functions used throughout Project 1's side-scroller game.
Official API reference for every p5.js function — useful for looking up shape, color, image, and input-handling methods while implementing Project 1 features.
Popular video series teaching programming fundamentals (variables, conditionals, functions, objects) through creative coding with p5.js. Good supplementary practice for students newer to the setup()/draw() paradigm.
A more thorough, ground-up introduction to unit testing itself — what a unit test is, black/white/gray box testing, and the arrange/act/assert pattern in depth — taught through Vitest. Good next step for students who want more than the required quick-start guide before diving into Project 1's tests.
Optional deep-dive reference — not assigned reading. Chapters 1 and 2 cover reliability, scalability, and data models for students who want the classic treatment.
Practical hands-on tutorial: building Docker images in GitLab pipelines, pushing to GitLab Container Registry, Docker-in-Docker setup, and predefined CI variables.
The official FastAPI documentation's tutorial — path/query parameters, request bodies with Pydantic, dependency injection, and async endpoints. Matches this course's actual backend stack directly (Projects 2–3 are both FastAPI, not Flask).
Required pre-class reading for Lecture 8: the Introduction, Store Passwords in a Secure Fashion, Compare Password Hashes Using Safe Functions, and Authentication and Error Messages. The rest is a reference for authentication best practices — password recovery, multi-factor auth, and more.
Required pre-class reading for Lecture 8: the Introduction (authentication vs. authorization) and the RBAC, ABAC, and ReBAC models, including OWASP's case for preferring ABAC/ReBAC in larger applications.
Clear, practical explanation of the OAuth 2.0 flow with sequence diagrams. Better than the RFC for learning purposes.
Unit 2 — Smart Applications Weeks 6–10
Resources for understanding how LLMs work, prompt engineering, local models with Ollama, RAG pipelines and vector databases, CI/CD deployment to GCP, cloud LLM APIs, agentic tool use, and production monitoring — everything needed for Lectures 10–19 and Projects 3–4.
Visual, intuitive treatment of transformer architecture, embeddings, semantic search, and RAG — from the author of the widely-used "Illustrated Transformer" explainer.
Required for Lecture 10: the first 30 minutes — how a model is pretrained on internet text into a base model, then fine-tuned into an assistant, with comparison labels (RLHF) as an optional third stage. Part 3, LLM Security (45:43–58:37), covers jailbreaks, prompt injection, and data poisoning — a preview of Unit 3.
A 3.5-hour, general-audience walkthrough of how ChatGPT-style models are built, with chapter timestamps: pretraining and tokenization; post-training on conversations, including the special tokens that mark each turn (1:01:06); hallucinations and tool use (1:20:32); reinforcement learning and DeepSeek-R1 thinking models (2:07:28); and RLHF (2:48:26). Required for Lecture 15: the "DeepSeek-R1" chapter (2:27:47–2:42:07). Recorded February 2025, so some provider details are dated.
Required for Lecture 12 (optional for Lecture 10), from the top of the page through the add_generation_prompt section: how a list of chat messages becomes one token sequence with model-specific control tokens such as <|im_start|>, and why the wrong template hurts a model. Shows the same format as Lecture 10's special-token slides.
Post-Training, RLHF & Reasoning Models
Optional deeper reading behind Lecture 10's training-stage and reasoning-model slides and Lecture 15's thinking-token slides.
Optional. Walks through the three phases behind ChatGPT-style models — pretraining, supervised fine-tuning, and RLHF with a reward model. Each phase includes the math, but the overview and the "why" sections read fine without it.
Optional. A diagram-led explanation of RLHF: train a reward model from human rankings, then fine-tune the language model against it, with a penalty that keeps it close to the original model.
Optional. What makes a model a "reasoning model," inference-time scaling, and how DeepSeek-R1 was trained with reinforcement learning and supervised fine-tuning. Goes deeper than Lecture 10's reasoning-model slides.
Optional reference. A free, regularly updated book on post-training: instruction tuning, reward models, preference optimization (including DPO), reinforcement learning for reasoning, and over-optimization. Background for Unit 3's alignment material.
Optional. Source of Lecture 10's training figures for the model family used in the Medical Knowledge Base arc: 18 trillion pretraining tokens, over 1 million supervised fine-tuning samples, and multistage reinforcement learning.
Required for Lecture 12 (whole paper). A dataset of 61,000+ prompts that developers wrote in open-source Python projects, an analysis of what those prompts look like, and a proposed static linter for prompts — treating prompts as code that deserves the same checks as the rest of the codebase.
Covers FAISS, dense passage retrieval, tokenizers, and LangChain retrieval chains with hands-on cloud labs. (The course itself uses ChromaDB directly rather than LangChain — useful as a comparison of an alternative framework, not a match for the project stack.)
Optional — not required. For students who want to read the primary research behind RAG beyond the Lewis et al. paper already assigned (Lecture 11); both are searchable full-text past the free abstract most search engines show.
Docs and quickstart for the dedicated embeddings/rerank server this course uses instead of a general-purpose LLM server's embeddings endpoint — covers its OpenAI-compatible /embeddings API and how embedding model choice determines pooling strategy (mean/CLS/last-token). Required pre-class reading for Lecture 13.
Official docs for the RAGAS open-source evaluation framework — covers faithfulness, answer relevance, and context recall metrics. Required pre-class reading for Lecture 14.
Required pre-class reading for Lecture 14. Covers custom, masked, and protected CI/CD variables — how to store secrets like SSH keys without committing them to the repository.
Official reference for creating a VM via the Console, gcloud, or the API — machine types, zones, boot disks, and startup options. Required-adjacent reading for Lecture 14's Compute Engine deployment activity; Lecture 19 redeploys using the exact same pattern, and the Final Project reuses it again later.
What's covered by GCP's Always Free tier (including one non-preemptible e2-micro instance per billing account in us-central1, us-west1, or us-east1) versus what still bills — relevant for not accidentally burning through the course's education credit on an oversized VM.
Cloud LLM APIs & Tool Use
Lectures 15–19 (the Automated Customer Support Agent arc) and Project 4 (Course Copilot) all standardize on Google's Gemini models via the google-genai SDK, called against Vertex AI in "Express Mode" (a plain API key, funded by the same GCP for Education credit used for Project 3's deployment) — not the Anthropic API.
Official reference for client initialization and content generation with the SDK this course uses starting Lecture 15. Required pre-class reading for Lecture 15.
Covers both blocking and streaming (generate_content_stream) calls, and the async client (client.aio) used for non-blocking calls in a web server. Required pre-class reading for Lecture 15.
How response_schema with a Pydantic model constrains Gemini's output to valid, type-safe JSON — no regex or markdown-fence stripping needed. Required pre-class reading for Lecture 16.
How to expose application functions to Gemini via FunctionDeclaration schemas and run the multi-turn tool-calling loop. Required pre-class reading for Lecture 17. Essential for Project 4.
Required for Lecture 16: the "What Is Structured Generation?" and "What Is Constrained Decoding and How Does It Work?" sections. Contrasts prompting and fine-tuning, which steer a model toward a format, with constrained decoding, which restricts each next token so the output always matches the structure.
Required for Lecture 17: the "Passing tools" and "Tool-calling Example" sections. Shows how tool schemas go into a chat template, the <tool_call> text a model generates, and how your code adds the result back as a tool message. Matches Lecture 17's "A Tool Call, as the Model Sees It" slide.
Optional. How llama.cpp constrains a local model's output with a grammar, including converting a JSON Schema into one — a concrete implementation of the constrained decoding taught in Lecture 16.
Per-model token prices. Output prices for thinking models such as gemini-2.5-flash include thinking tokens — why Lecture 15 and Project 4's cost tracking count thoughts_token_count as output.
How Express Mode authenticates with a plain API key instead of a full service-account credential file — the auth path this course uses on student laptops and in Project 4.
Reference for Claude's own models, tool use, streaming, and vision — useful for comparison (and still what Claude Code itself runs on), though Lectures 15–19 and Project 4 standardize on Google's Gemini API.
Covers function calling, assistants, structured outputs, and batch processing — another useful point of comparison to the Gemini API this course actually uses.
Build MCP servers and clients in Python from scratch — tools, resources, and prompts, MCP's three core primitives. A natural extension of Lecture 17's tool-use content for students who want to go deeper.
Covers agent architectures combining RAG and knowledge graphs — relevant background for both Project 3's retrieval work and Project 4's multi-agent Course Copilot.
Official tutorials covering chains, agents, memory, and RAG. Includes the LCEL (LangChain Expression Language) overview. Not used directly in this course's projects, but a useful point of comparison to the raw Anthropic SDK approach taught here.
Optional for Lecture 18: the pros and cons of chat interfaces, and why simple actions suit controls while complex ones suit language — the source of the lecture's action-complexity spectrum.
Official Sentry docs for setting up error tracking in Node.js or Python. Optional — not used in any project; useful industry context for Lecture 19's observability content.
Up-to-date per-model token pricing for the Gemini family, including gemini-2.5-flash-lite — the default model Project 4 uses for classification, generation, and verification calls. Essential for Project 4's per-AgentRun cost logging.
Covers the full LLM engineering stack: RAG, evals, LLMOps, fine-tuning, deployment, and production optimization.
Unit 3 — Security, Ethics & Harness Engineering Weeks 11–15
Resources for AI-specific security vulnerabilities, responsible AI and ethics, harness engineering and evaluation frameworks — everything needed for Lectures 20–27 and the Final Project.
AI Security & Red Teaming
Lectures 20, 22, 23, and 27 form the Security Lab Arc, run on Vault — a hosted service built for this course. The tools below are the real, industry-standard tooling that arc's activities are graded with or modeled on.
The industry standard reference for LLM vulnerability taxonomy. Required pre-class reading for Lecture 20 (LLM01: Prompt Injection) and Lecture 22 (the architecture/governance whitepaper).
Optional for Lecture 22: the four questions of threat modeling (what are we building, what can go wrong, what will we do about it, did we do a good job), with a STRIDE table and examples. Useful for the Vault threat-model take-home.
Optional for Lecture 22: one short page defining all six STRIDE categories — spoofing, tampering, repudiation, information disclosure, denial of service, elevation of privilege.
The real, zero-click indirect prompt injection that exfiltrated data from Microsoft 365 Copilot via a single crafted email — no user interaction required. Required pre-class reading for Lecture 22; Vault's own threat-modeling activity uses it as an anchor case.
Official quickstart for the industry-standard red-teaming tool that grades Lecture 23's guardrail-gateway activity — a static eval pass plus a redteam pass using promptfoo's own OWASP LLM Top 10 plugins.
Suggested reading — not required. NVIDIA’s open-source toolkit for runtime guardrails: colang flow definitions that spell out the allowed dialog paths, plus input, output, and topical rails. Lecture 23 teaches its architecture in class, next to Llama Guard, as one of two real guardrail designs.
Official docs for the open-source scanner used as attacker tooling in Lecture 27's live red/blue finale — probes for prompt injection, jailbreaks, hallucination, and data leakage.
Official docs for Microsoft's red-teaming framework, also used as attacker tooling in Lecture 27 — multi-turn adversarial strategies (e.g. Crescendo) against a live conversational target.
Uses PyRIT, NVIDIA garak, and promptfoo to systematically identify and mitigate LLM threats before deployment — the same three tools Lectures 23 and 27 use directly.
Interactive prompt injection challenges used in the world's largest AI red teaming competition. Optional pre-class reading for Lecture 20, before Vault's own PvP rounds.
Required pre-class reading for Lecture 23: Section 1 (Introduction), Section 6 (Lesson and Discussion, with its four numbered lessons), and Section 7 (Conclusion). The authors bypassed 12 published defenses against jailbreaks and prompt injection — prompting defenses, classifier (“filtering”) models, and models trained against known attacks — with over 90% success for most, though most had reported near-zero. The point: a defense tested only against a fixed set of known attacks says little about an attacker who adapts to it. Lecture 23’s guardrail is exactly this kind of defense, scored against exactly this kind of fixed test set. Sections 2–5 and the appendices are optimization detail and are not assigned.
Suggested reading — not required. Instead of making the model resist injected instructions, CaMeL builds a system layer around it: a privileged LLM plans from the trusted user request, a quarantined LLM with no tool access reads the untrusted data, and capability tags enforce security policies before any tool call, so untrusted data can never change what the program does. The “secure by design” end of Lecture 22’s defensive-architecture patterns, and relevant to Project 4’s tool-calling agent. Read the Introduction and “Defeating Prompt Injections by Design” sections, and the Discussion’s “So, Are Prompt Injections Solved Now?”
Suggested reading — not required. Names two reasons safety training fails: competing objectives, when a model's helpfulness conflicts with its safety goals, and mismatched generalization, when safety training doesn't cover inputs (like encoded text) the model can still understand. Explains why the attacks in Lecture 20's Vault rounds work.
Optional — not required. For students who want to go beyond the Greshake et al. and Llama Guard papers already assigned (Lectures 22 and 23) into the broader adversarial-ML and LLM-security literature.
Primary source reading — how a leading AI lab thinks about responsible deployment. Good discussion material for Lecture 24 (AI Ethics) and Lecture 27 (AI Governance).
Used by teams at OpenAI and Anthropic. Evaluates prompts, agents, and RAG apps via YAML config — integrates with CI/CD. This is the actual tool Lecture 23's guardrail-gateway activity is graded with (see the AI Security & Red Teaming table above for the red-team quickstart specifically).