The AI agents lecture slides in this site’s teaching kit are thirteen decks, one for every week of a thirteen-week course. Each is an HTML deck with presenter notes on every slide, plus a PDF without notes, linked from the teaching kit. They are licensed CC BY 4.0: reuse, adapt and translate them with attribution.
This page is the reference for those thirteen decks. I wrote the decks, so I have tried to state the limits as plainly as the contents.
What do the AI agents lecture slides contain?
The thirteen decks cover all thirteen weeks of the syllabus, each planned for 80 minutes, each with one in-class activity that uses a browser tool and at least one piece of out-of-class work plus a short reading quiz. Every number in the table is stated in the lecture’s own notes file.
| Lecture | Title | Stated length | Slides | In-class activity | Homework or lab | Reading, and whether it is free |
|---|---|---|---|---|---|---|
| 1 | What an Agent Is, and the Engine Underneath | 80 min | 28 | Should this be an agent?, pairs, 15 min | The tokenizer experiment, individual, about 1 hour | Preface, Chapter 1, Chapter 2 sections 1–3: all free |
| 2 | The Engine’s Failure Modes and the Loop | 80 min | 28 | How reliable must each step be?, pairs, 15 min | Lab 1: the minimal agent, with a scripted model client, individual, about 3 hours | Chapter 2 sections 4–6: free. Chapter 3 and Appendix A: full book |
| 3 | Planning, Tools, and the Action Space | 80 min | 29 | Lint seven flawed tools, fix them, re-lint; teams of three, 20 min | Lab 2: a verifier, a task-shaped tool and structured errors, individual, about 4 hours | Chapters 4 and 5: full book |
| 4 | Skills, Protocols, and Context Engineering | 80 min | 30 | Context rot, then budget a desk: explainer, then the budget planner; teams of three, 20 min | Lab 3: a skill folder, tool-result trimming and a progress file, individual, about 4 hours | Chapters 6 and 7: full book |
| 5 | Retrieval, Memory, and Workflow Patterns | 80 min | 30 | A support pipeline as a chain, then a router, on the whiteboard with the compounding-error calculator; teams of three, 20 min | Lab 4: a retriever, a constitution, compaction and quarantine, individual, about 8 hours in two sessions; a glossary scavenger hunt, about 30 minutes | Chapters 8 to 10: full book |
| 6 | Multi-Agent, Oversight, the Outer Loop, and When Not To | 80 min | 30 | A gate policy in the consequence tier classifier, then a brief in the multi-agent failure explorer; teams of three, 22 min | Lab 5: an approval gate in code and a minimal outer loop, individual, about 8 hours in two sessions; the project proposal, teams of two or three | Chapters 11 to 14: full book |
| 7 | Observability and Debugging | 80 min | 30 | Four traces, the first wrong span, in the trace waterfall viewer and the agent bug bestiary; teams of two or three, 24 min | Lab 6: a tracer and a record/replay layer, individual, about 10 hours in two or three sessions | Chapter 15: full book |
| 8 | Evaluating Agents | 80 min | 30 | Measure the measurement with the pass@k calculator, the eval sample-size calculator and the judge agreement calculator; teams of two or three, 25 min | Lab 7: the eval set v1, a team project milestone, about 10 hours in two or three sessions | Chapter 16: full book |
| 9 | Security, Safety, and Guardrails | 80 min | 30 | Three passes over three designs with Spot the injection, the lethal-trifecta audit and the tool-contract linter; teams of two or three, 24 min | No lab: a red team against another team’s agent, in a ring of teams, about 7 hours in two sessions | Chapter 17: full book |
| 10 | Reliability, State, and the Harness | 80 min | 32 | Break it on purpose, then map the harness, with the circuit breaker simulator and the harness grid builder; teams of two or three, 25 min | Lab 8: crash on purpose, a team project milestone, about 10 hours in two or three sessions | Chapter 18: full book |
| 11 | Cost, Latency, Deployment, and Scaling | 80 min | 34 | Price it, cache it, admit it, ship it, with four browser tools; teams of two or three, 26 min | No lab: a homework on the project’s cost per run, latency percentiles and step counts, with a triangle statement; teams, about 6 hours in two sessions | Chapters 19 and 20: full book |
| 12 | Coding Agents and Classifiers | 80 min | 35 | Split it, score it, price it, on the provided tickets.csv with three browser tools; teams of two or three, 26 min |
No required lab: the capstone. An optional lab on the ticket classifier, about 8 hours, replaces the lowest lab grade | Chapters 21, 22 and 26: full book |
| 13 | Research, Business, UX, Recipes, the Frontier, and Capstone Demos | 80 min (lecture session) | 38 | Price it, score it, place it, with three browser tools, in capstone teams, 24 min | No lab: getting ready for capstone demo day, with a premortem of the demonstration | Chapters 23, 24, 25 and 27: full book. Appendix C after the course |
Two things in that table differ from what the titles might suggest. There is no separate deck on the language model and no separate deck on the loop. The model takes the second half of lecture 1 and the first half of lecture 2, and the loop is the second half of lecture 2.
Only the Preface, Chapters 1 and 2 and the glossary are free online. Lecture 1’s reading is entirely free. Lecture 2’s is free for the Chapter 2 sections and in the full book for Chapter 3 and Appendix A. The readings of lectures 3 to 13 are in the full book.
Each deck prints this on its section slides, which read “(free)” or “(full book)”.
These AI agents lecture slides need no paid model API. The in-class tools run in a browser with no account and no API key. Lecture 1’s homework allows “any model you can reach for free”, and all eight labs replace the model with a script.
Where are the files, and how do the notes work?
Each lecture has one page with two buttons, “Open the slides” and “PDF”, and the instructor notes sit on that same page. The addresses follow the week number.
| What | Address |
|---|---|
| Lecture page (objectives, notes, exercises, readings) | /teach/lectures/01/, /02/, /03/, /04/, /05/, /06/, /07/, /08/, /09/, /10/, /11/, /12/, /13/ |
| HTML deck | /teach/lectures/01/deck.html (and 02 to 13) |
/teach/lectures/01/deck.pdf (and 02 to 13) |
The pages are lecture 1, lecture 2, lecture 3, lecture 4, lecture 5, lecture 6, lecture 7, lecture 8, lecture 9, lecture 10, lecture 11, lecture 12 and lecture 13.
How are the presenter notes shown?
Presenter notes appear when you press N in the HTML deck; F toggles fullscreen. Every slide has notes: 28, 28, 29, 30, 30, 30, 30, 30, 30, 32, 34, 35 and 38 of them. Adding ?notes to the deck’s address opens it with the notes panel already visible, and a slide number after # is a deep link, so deck.html#15 opens slide 15.
The PDF is the same deck with one slide per page and without notes. Lecture 1’s notes file describes it as meant “for handouts and for instructors who present from a PDF viewer”. If you present from the PDF, read the notes in the HTML deck beforehand, because they are nowhere in the PDF.
There is no slide-software file. The AI agents lecture slides exist as HTML pages and PDFs only, so editing a slide means editing HTML, or rebuilding the slide in your own tool with the attribution line attached. The free instructor pack has the HTML sources of all thirteen decks, with the slide engine they run on, in one .zip for editing offline.
What is on the lecture page besides the deck?
The lecture page holds the second kind of notes: prose written for the instructor. Each one has a section on how to run the session, the timing table, common misconceptions with a response to each, materials, and the exercises with acceptance criteria.
A commenter on Hacker News put the distinction this way: “The things that make for useful notes are very different from the things that make for good visual aids” (stevenbedrick, 9 October 2010). The slides here are visual aids. The presenter notes and the lecture page are the notes.
Lecture 1: what an agent is, and the engine underneath
Lecture 1 fixes the course vocabulary in its first half and explains how a language model produces text in its second. The first half follows Chapter 1 through the working definition of an agent, the chatbot, workflow and agent distinction, and the four compass bearings. The second half follows the first three sections of Chapter 2.
The notes file gives this plan, which I reproduce as printed:
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the trust question, the thesis, objectives | 1–3 | 7 |
| What an agent is: definition, control flow, why now | 4–7 | 10 |
| Chatbot, workflow, agent: the three systems, the litmus test, the augmented LLM, the dial | 8–12 | 14 |
| The compass and its forks; compounding error worked by hand | 13–15 | 10 |
| Do you need an agent? The ladder and the calibration pair | 16–17 | 6 |
| In-class exercise: Should this be an agent? in pairs, then debrief | 18 | 15 |
| The engine: next-token prediction, training vs inference, tokens | 19–22 | 9 |
| The desk, the lottery, nondeterminism | 23–25 | 7 |
| Recap, homework, reading | 26–28 | 2 |
The file also gives two variants. For 90 minutes, the exercise gets 20 and the other five go to slide 15, with students computing the table rows themselves. For 75 minutes, the debrief is shortened and slides 11 and 12 are merged into one pass.
What does lecture 1 assume?
This is my reading of the slides; the lecture file lists no prerequisites. No slide in lecture 1 carries code. Students need to know what a control-flow diagram is, because slides 9 and 10 turn on who decides what happens next. They need to raise a number to a power for slide 15, which works 0.95²⁰ as a labeled illustration.
Nothing in the deck expects a student to have called a model API or studied machine learning. The homework needs access to some free chat interface or a local open-weight model, which the file names only as categories.
Which misconceptions and activity does lecture 1 prepare?
The notes list six misconceptions with a response to each. Three of them: “An agent is any app with an LLM in it”, “The model remembers our earlier chats”, and “Temperature zero makes the output deterministic”.
Three slides are built to be answered by the room before you advance: slide 8, slide 20 and slide 24.
In the activity, pairs write three requests from their own work or studies and run each through the Should this be an agent? browser tool. They submit the tool’s Markdown export plus two lines per request: who owns the control flow, and what signal would tell them it worked. The notes also name a short explainer, What is an agent?, to play before the exercise or assign beforehand. The 80-minute table has no slot for it.
Lecture 2: the engine’s failure modes and the loop
Lecture 2 finishes Chapter 2 in its first half and teaches the loop in its second. The first half covers prompting in one slide, structured output and constrained decoding, function calling, six failure modes and compounding error with its three levers. The second half covers the loop, ReAct, the four parts of a minimal agent inside a harness, and the three exits.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the bridge from week 1, objectives | 1–3 | 4 |
| Prompting, structured output, constrained decoding | 4–7 | 9 |
| Function calling: the exchange, the tool definition, unhappy paths | 8–9 | 8 |
| Failure modes: hallucination, the jagged frontier, the six-row table | 10–12 | 9 |
| Compounding error derived, the three levers | 13–14 | 7 |
| In-class exercise: explainer, then the calculator in pairs, debrief | 15 | 15 |
| The loop: four beats, the index card, ReAct | 16–19 | 11 |
| The minimal agent: four parts, the harness, Appendix A’s program and run | 20–22 | 9 |
| Exits, the scripted client, frameworks | 23–25 | 6 |
| Recap, lab, reading | 26–28 | 2 |
For 90 minutes, the file plays the three-minute agent loop explainer on slide 17 and gives the rest to slide 18, tracing the chapter’s seven-pass checkout run on the board. For 75 minutes, it skips slide 5 and takes slide 25 as a one-line answer.
The split in the reading falls exactly at slide 16, the section slide marked “Part 2 · Chapter 3 and Appendix A (full book)”. An instructor without the book still has a complete deck with presenter notes for slides 16 to 28. The reading behind those slides is in the full book. For background on that half, the post on what an agent loop is explains the concept on its own.
What does lecture 2 assume?
Again, this is my reading. Lecture 2 assumes lecture 1: its opening segment is called “the bridge from week 1”. Four slides carry pseudocode or a schema: slide 9 (a tool definition), slide 18 (the loop on an index card), slide 21 (the execute function) and slide 24 (the lab’s scripted client). A student has to read a function definition, a list and a nested record.
Slide 6 asks students to sketch a parser, so they need to have written one small program. Slides 13 and 14 need independent events and a root: the exercise’s first answer is the twentieth root of 0.9, about 99.47%. Lab 1 asks for tests that pass with the machine offline, which presumes some unit-testing practice.
Which misconceptions and activity does lecture 2 prepare?
The notes list eight misconceptions. Three of them: “The model runs the tool”, “Structured output means the answer is correct”, and “Real agents need a framework”. Four slides are built to be answered first: 6, 8, 20 and 22. The notes also ask you to work slides 13 and 14 on the board.
The activity opens with the Why errors compound explainer, about three minutes. Pairs then answer four questions with the compounding-error calculator and submit its Markdown export with at most half a page of answers. Lab 1 has students type in Appendix A’s program in a language of their choice and swap the provider call for a scripted model client. It includes two tests that break the loop on purpose.
Lecture 3: planning, tools and the action space
Lecture 3 covers Chapter 4 in its first half and Chapter 5 in its second: how a goal becomes steps, whether a model can catch its own mistakes, and how to design the tools an agent acts through. Both chapters are in the full book. The notes file says the slides quote the chapters verbatim where it matters, so that students without the book can still follow the lecture.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the migration goal, objectives | 1–3 | 5 |
| Planning: decomposition, interleaved vs plan-then-execute, replanning, choosing | 4–8 | 13 |
| Reasoning: chain-of-thought, test-time compute, self-consistency | 9–10 | 7 |
| Self-correction: the prediction, two columns, find vs fix, the verifier rule and ladder | 11–15 | 12 |
| Tools: the action space, the calendar worked example, too many tools | 16–19 | 9 |
| The interface: anatomy, errors, retrofitting for agents (two slides) | 20–23 | 8 |
| In-class exercise: lint, fix, re-lint, then debrief | 24 | 20 |
| Code execution and computer use | 25–26 | 4 |
| Recap, Lab 2, reading | 27–29 | 2 |
The file is candid that the exercise is the tightest segment: 20 minutes leaves about 13 for the work and 7 for the debrief. With 85 minutes or more, the exercise gets the extra five first. For 75 minutes, the exercise drops to 17 and slides 25 and 26 take two minutes together. For 90 minutes, the exercise gets 30 and one team presents its whole redesigned set.
Slide 14 carries the sentence the first half builds to, from Chapter 4: “A real verifier beats the model grading itself.”
What does lecture 3 assume?
My reading once more. The notes refer back to week 1’s litmus test and to Chapter 3, so lecture 3 assumes both earlier lectures. Slide 2 opens on migrating a service off a deprecated payments API, and slide 18 asks whether wrapping three calendar endpoints would work. A student who has never called an API will need both examples explained.
Slide 21 shows an error as a JSON object, and the exercise hands teams seven tool definitions written as JSON with an input schema. Lab 2 begins “Extend your Lab 1 agent”, so it cannot be set on its own.
Which misconceptions and activity does lecture 3 prepare?
The notes list eight misconceptions. Three of them: “More planning is always safer”, “Asking the model to double-check its work catches errors”, and “A clean lint means a good tool”. Four slides are built to be answered first: 2, 8, 11 and 18.
In the activity, teams of three open seven deliberately flawed tool definitions in the tool-contract linter, fix the findings, look for two flaws the linter missed, and re-lint. They submit the fixed JSON, the linter’s Markdown export and a short note. The key, one redesign of the seven tools with the findings the linter should report, is in the instructor pack rather than on the public page, where students would find it.
This lecture asks one thing of you before class. Have the handout of seven definitions printed or posted, and check that the link on slide 24 opens the linter with the set loaded.
Lecture 4: skills, protocols and context engineering
Lecture 4 covers Chapter 6 in its first half and Chapter 7 in its second: skills loaded by progressive disclosure, the protocols that connect an agent to other systems, and the discipline of deciding what goes into the context window. Both chapters are in the full book. As in lecture 3, the notes file says the slides quote them verbatim where it matters.
Slide 2 opens on a week of watching a well-equipped agent, under Chapter 6’s line “Every tool call succeeds, and the work is still wrong.” The notes say the two halves are built so that the progressive-disclosure slide of the first returns, under another name, in the four operations of the second.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: every call succeeds and the work is wrong, objectives | 1–3 | 4 |
| Skills: the folder, the arithmetic, progressive disclosure, the description, three caveats with a quick budget run | 4–9 | 13 |
| The triad and protocols: which layer is missing, M×N, two kinds, the honest ledger | 10–14 | 10 |
| Inside a skill: five patterns, where good skills come from | 15–16 | 5 |
| Context engineering and context rot: the assembled window, the buried document, the attention budget, the soft limit | 17–21 | 10 |
| How context fails: the scene, the bedside chart, the clean-desk test | 22–23 | 6 |
| The four operations: the geometry, the table, all four in one run | 24–26 | 9 |
| In-class exercise: explainer, budget planner, debrief | 27 | 20 |
| Lab 3, recap, reading | 28–30 | 3 |
The exercise is again the tightest segment, so in class teams do only its first steps, and the rest is written up afterward and submitted with Lab 3. For 75 minutes, the file cuts slide 16 to one sentence and plays only the explainer’s last two beats. For 90 minutes, the exercise gets 30, the remaining steps are done in class, and one team presents its revised desk.
Slide 24 names the four verbs that every remedy in Chapter 7 reduces to: write, select, compress and isolate.
What does lecture 4 assume?
This is my reading again. Lab 3 begins “Extend your Lab 2 agent”, so it cannot be set without the two earlier labs. The notes refer back to week 3’s too-many-tools problem and to the desk sketched in Chapter 2, which the exercise reuses.
The protocols appear only as categories, each with one labeled example, and no slide teaches a protocol’s syntax or a vendor’s skill format. A student needs no prior experience with either. The arithmetic is multiplication, addition and a percentage: slide 12 asks for adapter counts, and the exercise reads utilization and steps from the planner.
Lab 3 asks for more testing than Lab 2. Students write scripted-client tests over a run of at least 30 model calls, and assert what each request does and does not contain.
Which misconceptions and activity does lecture 4 prepare?
The notes list twelve misconceptions. Three of them: “A skill is just a long system prompt”, “A bigger context window fixes context problems”, and “Let the agent write its own skills”. Five slides are built to be answered first: 2, 6, 11, 19 and 22. Slide 12 asks the room for a thirty-second calculation on paper.
The activity opens with the animated explainer Context rot and the four operations, about four minutes. Teams of three then load Chapter 2’s desk into the context window budget planner, run it at two hypothetical window sizes, and assign one of the four operations to each component of the desk. They submit the planner’s Markdown exports with their assignments and one sentence on what doubling the window bought. Lab 3 adds a skill folder loaded in levels, trimming of tool results once acted on, and a progress file the agent writes, and it checks the skill’s description with the skill token budget.
This lecture also asks something of you before class. Check that the links on slides 9 and 27 open both tools with their inputs loaded, and load the explainer and test the sound. The answers to the in-lecture checks, the expected numbers for the exercise and the Lab 3 key are in the instructor pack rather than on the public page.
Lecture 5: retrieval, memory and workflow patterns
Lecture 5 covers three chapters, one per part of the deck: Chapter 8 on retrieval, Chapter 9 on memory across long runs, and Chapter 10 on workflows, which opens Part IV of the book. All three are in the full book, and the notes file again says the slides quote them verbatim where it matters.
Slide 2 opens with a prediction: ask the most capable model you can reach about your own company’s refund policy, and say what comes back. The deck then builds the RAG pipeline, sorts memory into kinds, and ends on four ways of wiring model calls together when your code decides what happens next.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the refund-policy question, objectives | 1–3 | 4 |
| Retrieval: what looking it up buys, the pipeline, the missing error code, the levers, agentic retrieval | 4–9 | 12 |
| Three ways to know, and the room’s choice | 10–11 | 5 |
| Memory: the forgotten flag, the taxonomy, the sort, the tiers and the constitution, the lifecycle and its failures, a healthy long run, quarantine | 12–19 | 17 |
| Workflows: one unit and three overloads, chaining with gates, routing, parallelization, the evaluator–optimizer loop and its failure shapes | 20–26 | 19 |
| In-class exercise: chain, gates, router, the one loop | 27 | 20 |
| Lab 4, recap, reading | 28–30 | 3 |
For 75 minutes, the file cuts slide 9 to its first two sentences and slide 17 to the four failure modes, and keeps the exercise whole. For 90 minutes, it runs the glossary scavenger hunt in class as a ten-minute team race after the exercise.
Slide 19 states the rule that closes the memory part, Chapter 9’s quarantine: “Nothing enters an isolated context except what its brief deliberately admits, and nothing comes back out except a distilled result sized for the desk that will read it—carried as evidence, never as orders.”
What does lecture 5 assume?
My reading again. Lab 4 begins “Extend your Lab 3 agent”, so it needs all three earlier labs. The memory part leans on lecture 4: Chapter 9 picks up the verbs write, compress and isolate, and slide 18’s treatment for a long run starts from trimming tool results and the progress file of Lab 3.
The exercise reuses Chapter 1’s ticket pipeline and the compounding-error arithmetic of lecture 2. Nothing in the deck expects a student to have used a vector store or an embedding model; the notes say the deck names none, and Lab 4 allows TF-IDF as a stand-in for the meaning channel.
Lab 4 is the largest so far, about 8 hours in two sessions. Students need to rank text with a keyword score, fuse two ranked lists, and write tests that check what a request does and does not contain with marker strings.
Which misconceptions and activity does lecture 5 prepare?
The notes list fifteen misconceptions. Three of them: “RAG means the model stops making things up”, “The agent has memory”, and “A chain is safer than one call because each step is easier”. Four slides are built to be answered first: 2, 7, 13 and 15. Slide 11 asks the room to choose a road for three knowledge needs, with a minute on paper.
The activity is whiteboard work for teams of three. They draw Chapter 1’s support pipeline as a prompt chain with gates, read the effect of a verified retry from the compounding-error calculator, redraw the front as a router with three branches, and mark the one step that needs an evaluator–optimizer loop. They submit a photo of the two diagrams, the calculator’s Markdown export and a short note.
For homework, students also hunt this week’s twelve headwords in the glossary, which is free online. Lab 4 adds a hybrid retriever, a standing project-instructions file the agent cannot edit, bounded compaction, and a quarantined worker that returns a memo labeled as evidence.
Before class, check that the link on slide 27 opens the calculator with its inputs loaded, and make room on the whiteboard; the notes call it the week’s main instrument. The answers to the in-lecture checks, the expected numbers for the exercise, the glossary hunt key and the Lab 4 key are in the instructor pack rather than on the public page.
Lecture 6: multi-agent, oversight, the outer loop, and when not to
Lecture 6 covers four chapters, one per part of the deck, and closes Part IV of the book: Chapter 11 on multi-agent systems, Chapter 12 on oversight and autonomy, Chapter 13 on writing the outer loop, and Chapter 14 on when not to build an agent. All four are in the full book, and the notes file says once more that the slides quote them verbatim where it matters.
Slide 2 asks the room, before anything else, to write down the subtasks they would hand to a team of workers for a survey of managed vector databases. The deck then moves from splitting the work to signing for it, running it overnight, and deciding whether to buy it at all.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the subtasks you could not write, objectives | 1–3 | 4 |
| Multi-agent: the pattern and its bill, the one-line brief, the four fields, four seams, the merge wall, the verdict | 4–10 | 15 |
| Oversight: the sorting check, consequence tiers, the gate in code and the handoff, review theater, the autonomy dial | 11–16 | 14 |
| The outer loop: the one-line loop, its three lessons, the goal function, the five verbs, debts and brakes | 17–22 | 13 |
| When not to: four requests, the ladder priced, signs both ways and agent-washing | 23–26 | 8 |
| In-class exercise: a gate policy, then a brief | 27 | 22 |
| Lab 5, the proposal, recap | 28–30 | 4 |
The notes call four chapters in 54 minutes of lecture dense, so they hold the detail and each slide holds one idea. For 75 minutes, the file cuts slide 19 to its three cards, slide 15 to its four artifacts, and the debrief to 3 minutes. For 90 minutes, each team also runs the tier classifier on the draft tool list of its own project.
Slide 13 grades every action by what it costs when it is wrong, in four tiers from read-only to irreversible.
What does lecture 6 assume?
This is my reading. Lab 5 extends any of the earlier agents from Labs 2 to 4, so it needs at least the first two labs. Slide 5 builds on week 5’s fan-out, and the notes point ahead to week 9 for the attack hidden in a worker’s report.
No slide carries code beyond the one-line shell loop on slide 18, which students need only to read. The deck names no orchestration framework, coding agent or model. The ladder on slides 24 to 26 returns to the one on lecture 1’s slide 16, now with a price on each rung: plain code, a single call, a workflow and an agent.
Lab 5 is about 8 hours in two sessions, and its tests are the hardest so far. Students need to resolve file paths safely, including symbolic links, and to test a loop that survives a restart. The project proposal is due with it, written in teams of two or three.
Which misconceptions and activity does lecture 6 prepare?
The notes list fourteen misconceptions. Three of them: “Parallel agents make the work cheaper”, “Gate the actions the agent is unsure about”, and “Let the loop run until the agent says it’s done”. Five slides are built to be answered first: 2, 6, 12, 18 and 24. Slide 20 opens with its own one-sentence exercise, the stopping condition for “make the app better”.
In the activity, teams of three use two browser tools in 22 minutes. They answer the consequence tier classifier for a helpdesk agent’s seven tools and turn the autonomy dial to its tightest position. They then read a one-line brief in the multi-agent failure explorer and write a four-field brief for one worker. They submit both Markdown exports and a short note, which can be finished within 24 hours.
Lab 5 adds an approval gate in code for the two highest tiers, a handoff package for the person who decides, and a minimal outer loop over a checklist on disk, with a pass cap and a kill switch. The project proposal places the team’s own problem on the ladder and prices it with Chapter 14’s four-line quote.
Before class, check that both links on slide 27 open their tools with the inputs loaded. The keys to the in-lecture checks, the expected results of the exercise, the Lab 5 key and the proposal rubric are in the instructor pack rather than on the public page.
Lecture 7: observability and debugging
Lecture 7 opens Part V of the book with a single chapter, Chapter 15, in four parts: the trace that records one run, the monitoring that watches all of them, the reproduction of a failure that will not happen twice, and a field guide to six bug shapes. Chapter 15 is in the full book, and the notes file says the slides quote it verbatim where it matters.
Slide 2 starts from an afternoon every agent team lives through once. A user politely reports a wrong answer, and the room is asked which of its usual debugging tools will help.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the afternoon, objectives | 1–3 | 4 |
| Traces and spans: the flight recorder, the waterfall, what a span carries, the summary and the testimony, the standard and what not to capture | 4–10 | 14 |
| Monitoring: green dashboards, three questions and the tiles, drift, sampling and reading traces | 11–15 | 10 |
| Reproducing failures: the rerun, record and replay, the cheap version, the seam, golden traces and limits | 16–21 | 13 |
| The bestiary: six specimens, a five-span trace, the first wrong span, the flywheel | 22–26 | 10 |
| In-class exercise: four traces, the first wrong span | 27 | 24 |
| Lab 6, recap | 28–30 | 5 |
With one chapter in 51 minutes of lecture, the notes say the five room checks carry the week. For 75 minutes, the file folds slide 15 into slide 14’s notes, gives slide 19 one sentence, and cuts the debrief to 3 minutes. For 90 minutes, each team also writes the span schema for its own project’s tools.
Slide 18 is the part of the chapter that turns a failure you cannot repeat into one you can: record every crossing of the seam between your code and the outside world, then replay the run from the recording.
What does lecture 7 assume?
My reading once more. Lab 6 extends any of the agents from Labs 2 to 5, and the notes say the standard library is enough. The notes refer back to week 1’s demonstration that temperature zero does not make a model repeat itself, and point ahead to week 8, which measures pass rates.
The exercise hands teams traces as JSON to paste into a browser tool, so students need to read a nested record with spans that point to their parents. The deck names no observability platform, model or provider; it describes one open telemetry standard as an example of its category, without naming it.
Lab 6 is the largest lab so far, about 10 hours in two or three sessions. Its tests include a process killed mid-run in a subprocess and a replay that must fail loudly on any request it does not have.
Which misconceptions and activity does lecture 7 prepare?
The notes list twelve misconceptions. Three of them: “Good logging is observability”, “Set temperature to zero and the failure will reproduce”, and “The bug is where the run went visibly wrong”. Five slides are built to be answered first: 2, 8, 12, 17 and 24.
In the activity, teams of two or three read four invented traces in 24 minutes and name, for each, the first span where something is wrong. Two open as samples in the trace waterfall viewer, and two are printed on the lecture page as JSON to paste in. The last one also goes through the questions of the agent bug bestiary and ends as an eval set case. Teams submit the exports, the bestiary’s page address and a short note, which can be finished within 24 hours.
Lab 6 builds a tracer that writes every model call and tool call as a span, a record-and-replay layer at the seam, and a library of golden traces replayed against every new version of the code. It ends by turning one fixed failure into an eval case.
Before class, check the two links on slide 27 and paste both printed traces into the viewer once. The keys to the in-lecture checks, the expected results of the exercise, the Lab 6 key and its reference solution are in the instructor pack rather than on the public page.
Lecture 8: evaluating agents
Lecture 8 is the second half of the job lecture 7 began, again with a single chapter. Chapter 16 asks whether what the agent did was any good, and the deck follows its four moves: why the testing habits of ordinary software go quiet, how to build an eval set you believe in, how to calibrate a model that grades another model, and how to wire the instrument into daily work. Chapter 16 is in the full book, and the notes file says the slides quote it verbatim where it matters.
Slide 2 starts from a demo that went well in front of four colleagues and a question about rollout. The room writes down, on paper, the evidence it actually holds.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the demo afternoon, objectives | 1–3 | 4 |
| Why evaluation is hard: what breaks the unit-test habit, pass@k and passᵏ, the reliability envelope | 4–7 | 9 |
| Building an eval set: three runs, a testable criterion, the set, the state, the grader ladder, reading failures, how sure a pass rate is | 8–16 | 16 |
| LLM-as-a-judge: the instrument, two framings and four habits, four biases, calibration | 17–22 | 13 |
| Eval-driven development: every change reruns the suite, two suites and a gate, offline and online | 23–26 | 9 |
| In-class exercise: measure the measurement | 27 | 25 |
| Lab 7, recap | 28–30 | 4 |
For 75 minutes, the file drops one question of the exercise’s second part, gives slide 14 one sentence and folds it into slide 13’s notes, and cuts the debrief to 2 minutes. For 90 minutes, each team also drafts five tasks of its own project’s eval set, one of them a negative case.
Slide 7 draws the two honest summaries of the same attempts, pass@k and passᵏ, as the edges of one envelope.
What does lecture 8 assume?
This is my reading. Lab 7 is a team project milestone that starts from the failures of Lab 6 and keeps its tracer, so lecture 8 assumes lecture 7 and the project proposal of lecture 6. The notes say the testing habits of ordinary software are the starting point, so students should have written unit tests.
This is the most statistical lecture so far. Slide 6 asks for the chance that all of ten attempts succeed, slide 16 puts an interval on a pass rate, and slide 22 introduces a chance-corrected agreement statistic. The tools do the arithmetic, but a student needs introductory probability to read it.
The deck names no model, provider or evaluation platform. Lab 7 is about 10 hours in two or three sessions, and its gate script must block a version on stated conditions, each shown by a test.
Which misconceptions and activity does lecture 8 prepare?
The notes list eleven misconceptions. Three of them: “The demo worked, so the agent works”, “A higher pass rate means the change helped”, and “A green suite means the agent is good”. Four slides are built to be answered first: 2, 6, 15 and 21.
In the activity, teams of two or three spend 25 minutes measuring the measurement with three browser tools, each opened with invented data already filled in. The pass@k calculator asks how many attempts a product lives on, the eval sample-size calculator how sure a pass rate is, and the judge agreement calculator whether an LLM-as-a-judge may gate a suite. Teams submit the three Markdown exports and a note, which can be finished within 24 hours.
Lab 7 builds the first version of the project’s eval set, with every task proven passable, at least three runs per task, a calibrated judge and a regression gate. Infrastructure errors are counted apart from agent failures.
Before class, check that the exercise’s five links open with their numbers and that the judge link fills all three boxes. The keys to the in-lecture checks, the expected results of the exercise, the Lab 7 key and its reference solution are in the instructor pack rather than on the public page.
Lecture 9: security, safety and guardrails
Lecture 9 turns the instruments of weeks 7 and 8 toward an adversary, with a single chapter, Chapter 17, in five parts: prompt injection, the lethal trifecta, guardrails as a separate deterministic layer, the three dials that cap the blast radius, and the supply chain. Chapter 17 is in the full book, and the notes file says the slides quote it verbatim where it matters.
Slide 2 asks the room to commit to a prediction about an agent with a browser and one job, summarizing a product-review page, with a line in the footer no visitor has read. The notes say the chapter offers a posture rather than a fix, because the field does not have one.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the footer, objectives | 1–3 | 4 |
| Prompt injection: one stream, two routes, jailbreak versus injection, the confused deputy, why every model-layer defense is statistical | 4–10 | 13 |
| The lethal trifecta: the explainer, three legs, the leg that hides, the design method and the second audit | 11–14 | 11 |
| Guardrails: what enforces the prompt, four families, depth and placement, fail closed, a model as a guard, the costs | 15–18 | 9 |
| The blast radius: the approval question, least privilege, the sandbox and the allow-list, approval fatigue and the operator | 19–23 | 9 |
| The supply chain: two risks at once, tool poisoning and rug pulls, skills and configuration, the discipline | 24–26 | 6 |
| In-class exercise: three passes over three designs | 27 | 24 |
| Homework, recap | 28–30 | 4 |
For 75 minutes, the file assigns the explainer as viewing before class, gives slide 11 one sentence, and cuts the debrief to 2 minutes. For 90 minutes, each team also audits the design of the team it will attack in the homework and drafts its first payload’s route and aim.
Slide 12 counts the three capabilities that, held together, make a theft possible: private data, untrusted content and a way to send something out.
What does lecture 9 assume?
My reading again. There is no lab this week; the homework attacks the agents students have built, so it assumes their project code and the scripted clients of the earlier labs. Slide 18 calls a model used as a guard week 8’s judge in a second uniform, and slide 21 returns to the approval gate of lecture 6.
Slide 5 compares injection with SQL injection and its parameterized-query fix, so a student who has never met SQL injection will need it explained. The arithmetic is multiplying miss rates for layered defenses. The deck names no product, model or vendor as a target.
The notes say every payload in the week’s material is a classroom example aimed at the course’s own toy agents, written in a toy format that only the course’s scripted stub obeys. Nothing in the exercise or the homework targets a real product or service.
Which misconceptions and activity does lecture 9 prepare?
The notes list twelve misconceptions. Three of them: “Prompt injection is the model vendor’s alignment problem”, “Write the rules into the system prompt”, and “Ask the user before every action, to be safe”. Four slides are built to be answered first: 2, 9, 15 and 20. Slide 11 plays the explainer The lethal trifecta, about four minutes.
In the activity, teams of two or three make three passes over three designs in 24 minutes. They watch an injection land in Spot the injection, read a design into the lethal-trifecta audit themselves, and check a third-party tool server in the tool-contract linter before installing it. They submit the exports and a note, which can be finished within 24 hours.
The homework replaces the lab: a red team in a ring of teams, about 7 hours in two sessions. Each team hides three payloads in content the other team’s agent reads, grades each one on the state of the project rather than on what the agent says, and writes a one-page containment review. The defenders then apply the review and show the before-and-after results.
Before class, check that the explainer plays in the room with sound and that the exercise links open the first and third tools filled in, and publish who attacks whom. The keys to the in-lecture checks, the expected results of the exercise, the homework key and a reference solution for the red team are in the instructor pack rather than on the public page.
Lecture 10: reliability, state and the harness
Lecture 10 closes the part of the course about making agents dependable, with a single chapter, Chapter 18, in four parts: failing well, surviving a crash, degrading honestly, and how much harness to build. Week 7 recorded what a run did, week 8 measured it, and week 9 limited what it could break; this week takes the run that fails in the ordinary way. Chapter 18 is in the full book, and the notes file says the slides quote it verbatim where it matters.
Slide 2 puts the room twenty steps into a research task when a database connection is refused, and asks for the right response on paper. At 32 slides, it was the longest of these AI agents lecture slides until lecture 11.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the refused connection, objectives | 1–3 | 4 |
| Failing well: three wrong answers, five classes, backoff, jitter and the budget, timeouts and the breaker, the bill | 4–10 | 13 |
| State and recovery: where progress lives, two ways to checkpoint, keys and receipts, sequences and approvals, crash on purpose | 11–17 | 14 |
| Degrading honestly: the ladder, words and deeds, an escalation a person can use | 18–21 | 6 |
| The harness: where it is, the grid, sensors that speak, what it cannot see, two rooms and a scaling law | 22–28 | 14 |
| In-class exercise: break it on purpose, then map the harness | 29 | 25 |
| Lab 8, recap | 30–32 | 4 |
For 75 minutes, the file drops one question of the exercise’s first part, gives slide 16 one sentence, and cuts the debrief to 1 minute. For 90 minutes, each team also writes the failure table for its own project’s tools, which goes straight into Lab 8.
Slide 24 lays out the harness on two axes: whether a control acts before or after the agent does, and whether it is code or a model.
What does lecture 10 assume?
This is my reading. Lab 8 is a team project milestone and keeps Lab 6’s tracer and Lab 7’s suite running on the project, so lecture 10 assumes weeks 7 and 8. Slide 16 returns to the approvals of lecture 6, and the notes place the week after week 9’s limits on what a run can break.
The deck uses ordinary distributed-systems vocabulary: retries, timeouts, checkpoints and idempotency. Students who have built a web service will recognize most of it; others will need slides 8, 9 and 15 taken slowly.
Lab 8 is about 10 hours in two or three sessions. It asks students to kill a process for real between a side effect and its receipt, restore from a checkpoint, and prove the action did not repeat.
Which misconceptions and activity does lecture 10 prepare?
The notes list ten misconceptions. Three of them: “When a call fails, retrying is the safe default”, “A cached answer is worse than no answer”, and “The harness is the framework we bought”. Four slides are built to be answered first: 2, 7, 14 and 27.
In the activity, teams of two or three spend 25 minutes breaking things on purpose and then mapping the harness. The circuit breaker and retry simulator opens with a failing dependency already set up, and the harness grid builder opens with five controls to place, before each team maps its own project. They submit both Markdown exports and a note, which can be finished within 24 hours.
Lab 8, Crash on purpose, makes the project’s agent survive its own death. It adds failure classes routed to one primitive each, retries with jitter under one budget, a breaker in front of a fallback ladder whose bottom rung is a person, checkpoints, and idempotency keys with receipts.
Before class, check that the exercise links open with their numbers and that the harness grid link shows its five controls with the dials set. The keys to the in-lecture checks, the expected results of the exercise, the Lab 8 key and its reference solution are in the instructor pack rather than on the public page.
Lecture 11: cost, latency, deployment and scaling
Lecture 11 puts prices on everything the course has built, with two chapters in four parts. Chapter 19 reads the two meters every run carries, the invoice and the clock, and ends on the trade between them and quality; Chapter 20 puts the agent behind an endpoint, where strangers send it work, and ships a change safely. Both chapters are in the full book, and the notes file says the slides quote them verbatim where it matters.
Slide 2 hands the room a napkin calculation: what a ten-step run costs against one chat call. At 34 slides, it was the longest of the AI agents lecture slides until lecture 12.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the napkin, objectives | 1–3 | 4 |
| The invoice: the explainer, the staircase, what the napkin leaves out, yield, five levers, prompt caching | 4–9 | 15 |
| The clock and the triangle: three complaints, prefill and decode, the felt wait, parallelism and the other levers, pick two, on purpose | 10–16 | 10 |
| Serving: the wall, take a number, a row and not a process, rooms by the thousand, launch week, two axes and the door | 17–25 | 13 |
| The rollout ladder: Tuesday’s edit, the rungs, the canary’s disciplines, the flag and the artifact | 26–30 | 8 |
| In-class exercise: price it, cache it, admit it, ship it | 31 | 26 |
| Homework, recap | 32–34 | 4 |
For 75 minutes, the file assigns the explainer as viewing before class, gives slide 4 one sentence, and cuts slide 22 to its title. For 90 minutes, one exercise question moves into the room: each team fits the staircase to one of its own traces by hand.
Slide 5 draws the staircase: the model holds nothing between calls, so every step re-reads the run so far, and the input bill grows faster than the step count.
What does lecture 11 assume?
This is my reading. The homework runs on the project’s own traces from Lab 6’s tracer and Lab 7’s tasks, and the notes start from week 10’s agent that retries, checkpoints and keeps receipts. Slide 21 brings week 10’s patterns back for workers that are killed on schedule.
The arithmetic is the most algebraic in the course: slide 5 sums a growing series, and the homework asks for percentiles and a histogram. Serving needs a little web vocabulary, such as an HTTP endpoint, a load balancer and a rate limit, which slides 18 to 25 use without defining at length.
There is no lab this week. The homework, about 6 hours in two sessions for teams, turns the project’s traces into three meters and uses them to set the step budget.
Which misconceptions and activity does lecture 11 prepare?
The notes list eleven misconceptions. Three of them: “The goal is to spend fewer tokens”, “Streaming makes the agent faster”, and “Raise the timeouts and long tasks will work”. Four slides are built to be answered first: 2, 11, 18 and 23. Slide 4 plays the explainer Why agent cost compounds, about four minutes.
In the activity, teams of two or three spend 26 minutes on four browser tools, each opened with its inputs filled in. They price a run in the agent cost-per-task estimator, read the prompt caching bill in prompt caching savings, push a launch-week rush through the queue and backpressure simulator, and draft a canary rollout in the rollout plan generator. They submit the four exports and a note, which can be finished within 24 hours.
The homework measures cost per run, latency percentiles and the distribution of step counts from the team’s own traces. It ends with a triangle statement for each user-facing feature: which corner it sacrifices, how far, and which reading triggers a rethink.
Before class, check that the explainer plays with sound and that the four links open with their numbers. The keys to the in-lecture checks, the expected results of the exercise, the homework key and its reference script are in the instructor pack rather than on the public page.
Lecture 12: coding agents and classifiers
Lecture 12 visits two places where the machinery of the course already earns its keep, with three chapters in four parts. Chapter 21 asks why software was the field where agents first shipped work, Chapter 22 follows a working day with a coding agent, and Chapter 26 builds a classifier you can read and measure. All three are in the full book, and the notes file says the slides quote them verbatim where it matters.
Slide 2 leaves two tasks running unattended over a weekend, with the same model and harness, and asks each student to write down which one they would trust and why. At 35 slides, it was the longest of the AI agents lecture slides until lecture 13.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the weekend, objectives | 1–3 | 4 |
| Why coding went first: the domain grades its own work, the loop, two engineers, the spectrum, agent-legible code, the ground-truth loop | 4–10 | 10 |
| Briefs down, receipts up: brainstorm to execute, spec-driven development, tests first, TCR, savepoints and recorded proof, cognitive debt | 11–17 | 14 |
| A classifier you can read: the examiner, the two-headed ticket, a definition’s anatomy, examples, the worksheet, where a label went wrong, scores | 18–25 | 13 |
| Measurement you cannot fool: twenty for twenty, three sets, counting, the folder and the fresh desk, the cascade | 26–31 | 9 |
| In-class exercise: split it, score it, price it | 32 | 26 |
| Optional lab and reading, recap, close | 33–35 | 4 |
For 75 minutes, the file gives slides 16 and 17 one sentence each and cuts slide 25 to its title and the severity scale. For 90 minutes, each team also turns slide 25’s severity request into a four-level scale and scores ten tickets with a partner.
Slide 10 strips the story of coding agents to a template with four slots, starting from a goal a machine can check, so that it can be carried into another field.
What does lecture 12 assume?
This is my reading. The measurement half points week 8’s instruments, the kappa and the interval, at a classifier still being written, so it assumes lecture 8. Slide 30 packages the classifier as a skill folder, which assumes lecture 4.
The coding half assumes students have used version control and written tests: slides 14 to 16 cover tests first, test-and-commit-or-revert, and commits as savepoints. Nobody needs to have used a particular coding agent; the deck names none.
For data, the lecture ships a ready-made class set: tickets.csv, 200 invented support tickets for a fictional product, each labeled with one of four classes. It downloads from the lecture page, and the exercise and the optional lab both run on it, so no instructor has to build or clean data for the week.
Which misconceptions and activity does lecture 12 prepare?
The notes list twelve misconceptions. Three of them: “Green tests mean the code is correct”, “Our classifier scores 20 out of 20”, and “A high flag rate is safe”. Four slides are built to be answered first: 2, 7, 20 and 27.
In the activity, teams of two or three spend 26 minutes on the ticket set with three browser tools. They split it into three disjoint sets in the three-set splitter, score a first classifier against the labels in the judge agreement calculator, revise it once, and price a cheap screen in front of a detailed pass in the cascade cost estimator. They submit the splitter’s files, the exports and a note, which can be finished within 24 hours.
There is no required lab this week; the time goes to the capstone, whose demonstrations come in week 13. An optional lab, about 8 hours, builds the ticket classifier as a skill folder, revises it at least twice, and has the instructor open the sealed set once. It replaces the student’s lowest lab grade.
Before class, check that the ticket file downloads from the lecture page and that the calculator link opens with its matrix filled in. The keys to the in-lecture checks, the expected results of the exercise, the key to the optional lab and its reference implementation are in the instructor pack rather than on the public page.
Lecture 13: research, business, UX, recipes, the frontier, and capstone demos
Lecture 13 closes the course and hands it to the teams. Its lecture block covers four chapters: Chapter 23 on research and business agents, Chapter 24 on the room in which a person supervises an agent, Chapter 25 on recipes that recur across fields, and Chapter 27 on the frontier. All four are in the full book; Appendix C, the annotated source map, is set as reading after the course.
The rest of the week is capstone demo day, and the deck carries both: the lecture block (slides 1 to 30), a workshop on each team’s own project (slide 31), a demo-day briefing (slides 32 to 34) and the close of the course (slides 35 to 38). At 38 slides, it is the longest of the AI agents lecture slides.
| Segment | Slides | Minutes |
|---|---|---|
| Opening: the brief, objectives | 1–3 | 4 |
| Words without a compiler: two hires, the verification gap, four substitutes, grounding, the clerk, the budget meeting | 4–11 | 12 |
| The control room: two colleagues, appropriate reliance, the board, steering and alarms, directing | 12–17 | 9 |
| The pattern book: point-task or recipe, the slider, eight recipes, three placements | 18–22 | 7 |
| The map and the weather: the map, the lock, generator and gate, property-based tests, layers, the portable core, directions and habits | 23–30 | 11 |
| Workshop: price it, score it, place it | 31 | 24 |
| Demo-day briefing | 32–34 | 5 |
| Looking back, what is left, recap, close | 35–38 | 8 |
That table is the lecture session. The file gives two ways to schedule the week, by the number of teams. In the recommended one, the demonstrations get their own session or sessions, in slots of twelve minutes or, for large classes, ten. With five teams or fewer, a single 80-minute slot holds a short lecture path, the briefing and five demonstrations; the instructor pack has a capacity table by team count.
For 75 minutes, the file shortens slides 22 and 36 and lets Part C of the workshop finish as homework. For 90 minutes, each team also writes a premortem of its own demonstration and its mirror.
Slide 7 sets out the four partial substitutes for a compiler of facts: citations that can be opened, grounding, a spot-check chosen by consequence, and a judge calibrated against your labels.
What does lecture 13 assume?
My reading, for the last time. Lecture 13 assumes the whole course, because its workshop and its demo day run on each team’s capstone. Demo day opens on the eval dashboard of lecture 8, shows a trace from lecture 7’s tracer, and grades by passᵏ, so a team that skipped those weeks has nothing to show.
Slide 20’s autonomy slider is week 6’s dial seen from the product side, and slide 26’s generator and gate is the top of week 3’s verifier ladder. Slides 26 and 27 introduce property-based tests as a gate; students who have only written example-based tests will need them explained.
Students should know the schedule, their slot and their panel a week ahead. There is no lab this week; the homework is getting ready for the demonstration.
Which misconceptions and activity does lecture 13 prepare?
The notes list eleven misconceptions. Three of them: “A research report with forty citations has been checked”, “Good agent UX makes people trust the agent”, and “The demo is where we show the agent working”. Four slides are built to be answered first: 2, 10, 13 and 25.
The workshop runs in the capstone teams for 24 minutes with three browser tools. Teams price two hires in the ROI versus risk map, re-mark a scorecard in the agent verifiability scorecard the way a demo panel would, and run all three tools, with the agent recipe picker, on their own project. Part C’s three exports feed the demonstration, which ends on the team’s scorecard.
Demo day has three rules from the syllabus’s capstone brief: no cherry-picked runs; open on the eval dashboard, show a trace the panel picks, end on the scorecard; and grade by passᵏ. The homework asks each team for a premortem of its own demonstration (“it went badly: what happened?”) and its mirror, and to fix what the first one names.
Before class, check that the workshop links open with their inputs filled in, and publish the demo plan. The keys to the in-lecture checks, the expected results of the workshop and the demo-day grading notes are in the instructor pack rather than on the public page.
How would I adapt each lecture to the room?
The table below is my own advice, and the lecture files contain none of it. They give slot variants and misconceptions and say nothing about cohorts. I cite no study for these rows and claim no outcome. Each row moves minutes between real segments, and the arithmetic is shown so you can check it.
- CS majors without ML are the students the syllabus prerequisites describe: programming, introductory probability, ordinary software practice.
- Mixed engineering means a room drawn from several engineering programs, where I assume probability is comfortable and JSON or unit tests less so.
- Working professionals in an evening class write software for a living and bring real tasks.
- A 50-minute slot fits none of the lectures, so each one is split across two sittings.
| Lecture | What I would cut or shorten | What I would add or extend | Minutes | Cohort |
|---|---|---|---|---|
| 1 | Nothing | Nothing; run the file’s table | 7+10+14+10+6+15+9+7+2 = 80 | CS majors without ML |
| 2 | Nothing | Nothing; run the file’s table | 4+9+8+9+7+15+11+9+6+2 = 80 | CS majors without ML |
| 3 | Nothing | Nothing; run the file’s table | 5+13+7+12+9+8+20+4+2 = 80 | CS majors without ML |
| 4 | Nothing | Nothing; run the file’s table | 4+13+10+5+10+6+9+20+3 = 80 | CS majors without ML |
| 5 | Nothing | Nothing; run the file’s table | 4+12+5+17+19+20+3 = 80 | CS majors without ML |
| 6 | Nothing | Nothing; run the file’s table | 4+15+14+13+8+22+4 = 80 | CS majors without ML |
| 7 | Nothing | Nothing; run the file’s table | 4+14+10+13+10+24+5 = 80 | CS majors without ML |
| 8 | Nothing | Nothing; run the file’s table | 4+9+16+13+9+25+4 = 80 | CS majors without ML |
| 9 | Nothing | Nothing; run the file’s table | 4+13+11+9+9+6+24+4 = 80 | CS majors without ML |
| 10 | Nothing | Nothing; run the file’s table | 4+13+14+6+14+25+4 = 80 | CS majors without ML |
| 11 | Nothing | Nothing; run the file’s table | 4+15+10+13+8+26+4 = 80 | CS majors without ML |
| 12 | Nothing | Nothing; run the file’s table | 4+10+14+13+9+26+4 = 80 | CS majors without ML |
| 13 | Nothing | Nothing; run the file’s table | 4+12+9+7+11+24+5+8 = 80 | CS majors without ML |
| 1 | Slides 13–15 from 10 to 8: take slide 14, “One design fork per bearing”, in one pass | Slides 8–12 from 14 to 16: draw one control-flow diagram together on slide 10 | 7+10+16+8+6+15+9+7+2 = 80 | Mixed engineering |
| 2 | Slides 4–7 from 9 to 7 by skipping slide 5; slides 23–25 from 6 to 3 by taking slide 25 in one line | Slides 8–9 from 8 to 10: read slide 9’s argument schema aloud. Slides 16–19 from 11 to 14: read slide 18’s index card line by line | 4+7+10+9+7+15+14+9+3+2 = 80 | Mixed engineering |
| 3 | Slides 25–26 from 4 to 2, in one pass | Slide 24 from 20 to 22: read one handout definition together before teams start | 5+13+7+12+9+8+22+2+2 = 80 | Mixed engineering |
| 4 | Slides 15–16 from 5 to 3: cut slide 16 to one sentence | Slides 24–26 from 9 to 11: walk slide 26’s run together, one operation at a time | 4+13+10+3+10+6+11+20+3 = 80 | Mixed engineering |
| 5 | Slides 4–9 from 12 to 10: cut slide 9 to its first two sentences | Slides 20–26 from 19 to 21: write one gate together on slide 22 as a condition code can check | 4+10+5+17+21+20+3 = 80 | Mixed engineering |
| 6 | Slides 17–22 from 13 to 11: cut slide 19 to its three cards | Slides 11–16 from 14 to 16: walk slide 14’s path from proposal to execution, one box at a time | 4+15+16+11+8+22+4 = 80 | Mixed engineering |
| 7 | Slides 16–21 from 13 to 11: give slide 19 one sentence | Slides 4–10 from 14 to 16: read slide 6’s waterfall together, one span at a time | 4+16+10+11+10+24+5 = 80 | Mixed engineering |
| 8 | Slides 8–16 from 16 to 14: give slide 14 one sentence and fold it into slide 13 | Slides 23–26 from 9 to 11: sketch slide 25’s gate as a step in a build pipeline | 4+9+14+13+11+25+4 = 80 | Mixed engineering |
| 9 | Slides 11–14 from 11 to 7: assign the explainer before class | Slides 19–23 from 9 to 13: walk slide 22’s sandbox and allow-list as the operating system enforces them | 4+13+7+9+13+6+24+4 = 80 | Mixed engineering |
| 10 | Slides 11–17 from 14 to 12: give slide 16 one sentence | Slides 4–10 from 13 to 15: work slide 9’s breaker through its three states on the board | 4+15+12+6+14+25+4 = 80 | Mixed engineering |
| 11 | Slides 4–9 from 15 to 11: assign the explainer before class | Slides 17–25 from 13 to 17: draw slide 20’s take-a-number flow and slide 25’s door on the board | 4+11+10+17+8+26+4 = 80 | Mixed engineering |
| 12 | Slides 11–17 from 14 to 11: give slides 16 and 17 one sentence each | Slides 26–31 from 9 to 12: work slide 29’s kappa beside accuracy on the board | 4+10+11+13+12+26+4 = 80 | Mixed engineering |
| 13 | Slides 18–22 from 7 to 5: give slide 22 its title and the composition line | Slides 23–30 from 11 to 13: work slide 27’s property-based test as a gate on the board | 4+12+9+5+13+24+5+8 = 80 | Mixed engineering |
| 1 | Slides 4–7 from 10 to 7: take slides 6 and 7 briefly. Slides 8–12 from 14 to 12 by merging slides 11 and 12 | Slide 18 from 15 to 20: pairs bring requests from their jobs | 7+7+12+10+6+20+9+7+2 = 80 | Working professionals (evening) |
| 2 | Slides 4–7 from 9 to 7 by skipping slide 5 | Slides 23–25 from 6 to 8: give slide 25, “Shouldn’t I just use a framework?”, the two minutes | 4+7+8+9+7+15+11+9+8+2 = 80 | Working professionals (evening) |
| 3 | Slides 9–10 from 7 to 5: take slide 10 in one pass. Slides 25–26 from 4 to 2 | Slide 24 from 20 to 24: more time on the flaws the linter missed | 5+13+5+12+9+8+24+2+2 = 80 | Working professionals (evening) |
| 4 | Slides 17–21 from 10 to 8: take slide 18, “One window, four authors”, in one pass | Slides 10–14 from 10 to 12: pairs put slide 11’s question to one gap in an agent from their own work | 4+13+12+5+8+6+9+20+3 = 80 | Working professionals (evening) |
| 5 | Slides 12–19 from 17 to 15: cut slide 17 to the four failure modes | Slides 10–11 from 5 to 7: pairs choose a road for one knowledge need from their own work | 4+12+7+15+19+20+3 = 80 | Working professionals (evening) |
| 6 | Slides 17–22 from 13 to 11: cut slide 19 to its three cards | Slides 23–26 from 8 to 10: pairs place one request from their own work on the ladder | 4+15+14+11+10+22+4 = 80 | Working professionals (evening) |
| 7 | Slides 11–15 from 10 to 8: fold slide 15 into slide 14 | Slides 22–26 from 10 to 12: pairs place one failure from their own work among slide 23’s six specimens | 4+14+8+13+12+24+5 = 80 | Working professionals (evening) |
| 8 | Slide 27 from 25 to 23: drop the exercise question the file’s 75-minute variant drops | Slides 8–16 from 16 to 18: pairs write slide 10’s testable criterion for one task from their own work | 4+9+18+13+9+23+4 = 80 | Working professionals (evening) |
| 9 | Slides 4–10 from 13 to 11: take slide 7, jailbreak versus injection, in one pass | Slides 24–26 from 6 to 8: pairs list the third-party tool servers and skills their own agents load | 4+11+11+9+9+8+24+4 = 80 | Working professionals (evening) |
| 10 | Slide 29 from 25 to 23: drop the exercise question the file’s 75-minute variant drops | Slides 18–21 from 6 to 8: pairs draft slide 21’s escalation for one failure from their own work | 4+13+14+8+14+23+4 = 80 | Working professionals (evening) |
| 11 | Slides 17–25 from 13 to 12: cut slide 22 to its title | Slides 10–16 from 10 to 11: pairs name the corner of the triangle one feature of their own sacrifices | 4+15+11+12+8+26+4 = 80 | Working professionals (evening) |
| 12 | Slides 18–25 from 13 to 11: cut slide 25 to its title and the severity scale | Slides 11–17 from 14 to 16: pairs set slide 12’s workflow beside how their own team uses coding agents | 4+10+16+11+9+26+4 = 80 | Working professionals (evening) |
| 13 | Slides 18–22 from 7 to 5, as above. Slides 35–38 from 8 to 7: slide 36’s left column only | Slides 4–11 from 12 to 15: pairs place one use case from their own work on slide 11’s two axes | 4+15+9+5+11+24+5+7 = 80 | Working professionals (evening) |
| 1 | Nothing; split after slide 15 | Sitting A, slides 1–15 (41): the What is an agent? explainer (4) and students computing slide 15’s rows (5). Sitting B, slides 16–28 (39): reopen with slides 8 and 10 (6); exercise at 20 (5) | A: 41+4+5 = 50. B: 39+6+5 = 50. Total 100 = 80+20 | 50-minute slot |
| 2 | Slide 5 skipped (2); split after slide 15 | Sitting A, slides 1–15, is full. Sitting B, slides 16–28 (28): the agent loop explainer on slide 17 (3), the seven-pass run traced on slide 18 (7), a start on Lab 1 from slides 24 and 27 (12) | A: 4+7+8+9+7+15 = 50. B: 28+3+7+12 = 50. Total 100 = 80−2+22 | 50-minute slot |
| 3 | Nothing; split after slide 15 | Sitting A, slides 1–15 (37): pairs place their own tasks in slide 8’s table (8); name a verifier and a fallback critic on slide 15 (5). Sitting B, slides 16–29 (43): reopen with slide 14 (2); exercise at 25 (5) | A: 37+8+5 = 50. B: 43+2+5 = 50. Total 100 = 80+20 | 50-minute slot |
| 4 | Nothing; split after slide 21 | Sitting A, slides 1–21 (42): slide 12’s calculation worked in pairs on paper (5); pairs put slide 11’s question to a gap from their own work (3). Sitting B, slides 22–30 (38): reopen with slide 21 (2); exercise at 30, with its later steps done in class (10) | A: 42+5+3 = 50. B: 38+2+10 = 50. Total 100 = 80+20 | 50-minute slot |
| 5 | Nothing; split after slide 19 | Sitting A, slides 1–19 (38): the glossary hunt as a team race (10); pairs list, by kind, what their own agent should remember between sessions on slide 14 (2). Sitting B, slides 20–30 (42): reopen with slide 19 (2); a start on Lab 4 from slide 28 (6) | A: 38+10+2 = 50. B: 42+2+6 = 50. Total 100 = 80+20 | 50-minute slot |
| 6 | Nothing; split after slide 16 | Sitting A, slides 1–16 (33): pairs sort the tools of an agent from their own work into slide 13’s tiers (10); pairs write a four-field brief for one of slide 2’s workers on slide 7 (7). Sitting B, slides 17–30 (47): reopen with slide 14 (3) | A: 33+10+7 = 50. B: 47+3 = 50. Total 100 = 80+20 | 50-minute slot |
| 7 | Nothing; split after slide 21 | Sitting A, slides 1–21 (41): pairs sketch the span tree of one run of their own agent on slide 6 (5) and list which of slide 7’s attributes their logs lack (4). Sitting B, slides 22–30 (39): reopen with slide 20’s seam (3); the span schema for their own project’s tools (8) | A: 41+5+4 = 50. B: 39+3+8 = 50. Total 100 = 80+20 | 50-minute slot |
| 8 | Nothing; split after slide 22 | Sitting A, slides 1–22 (42): pairs write slide 10’s criterion for a task of their own (4) and place it on slide 13’s grader ladder (4). Sitting B, slides 23–30 (38): reopen with slide 22 (2); five tasks of their own eval set, one negative, with a debrief (10) | A: 42+4+4 = 50. B: 38+2+10 = 50. Total 100 = 80+20 | 50-minute slot |
| 9 | Nothing; split after slide 18 | Sitting A, slides 1–18 (37): pairs run the lethal-trifecta audit on an agent of their own (8) and place its guards in slide 16’s four families (5). Sitting B, slides 19–30 (43): the file’s 90-minute Part D, the first payload’s route and aim, without its debrief (7) | A: 37+8+5 = 50. B: 43+7 = 50. Total 100 = 80+20 | 50-minute slot |
| 10 | Nothing; split after slide 21 | Sitting A, slides 1–21 (37): pairs sort the failures of their own tools into slide 6’s five classes (8) and mark which tools need a key and a receipt (5). Sitting B, slides 22–32 (43): reopen with slide 17 (2); a start on Lab 8 from slide 30 (5) | A: 37+8+5 = 50. B: 43+2+5 = 50. Total 100 = 80+20 | 50-minute slot |
| 11 | Nothing; split after slide 16 | Sitting A, slides 1–16 (29): the file’s 90-minute question, each team fitting the staircase to one of its own traces, with its debrief (10); pairs name the corner one feature of their own sacrifices on slide 15 (6) and answer slide 13’s question for their own agent (5). Sitting B, slides 17–34 (51): slide 22 cut to its title (−1) | A: 29+10+6+5 = 50. B: 51−1 = 50. Total 100 = 80+21−1 | 50-minute slot |
| 12 | Nothing; split after slide 25 | Sitting A, slides 1–25 (41): pairs fill slide 10’s four slots for a task from their own field (5) and write slide 21’s anatomy for one class of their own (4). Sitting B, slides 26–35 (39): reopen with slide 24 (1); the file’s 90-minute severity scale, with its debrief (10) | A: 41+5+4 = 50. B: 39+1+10 = 50. Total 100 = 80+20 | 50-minute slot |
| 13 | Nothing; split after slide 30 | Sitting A, slides 1–30 (43): teams place their capstone on slide 20’s slider (4) and name which of slide 7’s substitutes checks its output (3). Sitting B, slides 31–38 (37): reopen with slide 28 (3); the file’s 90-minute premortem, with its debrief (10) | A: 43+4+3 = 50. B: 37+3+10 = 50. Total 100 = 80+20 | 50-minute slot |
Some of these moves come from the files’ own variants: merging slides 11 and 12, skipping slide 5, taking slide 25 in one line, compressing slides 25 and 26, extending the exercises of lectures 1, 3 and 4, cutting lecture 4’s slide 16 to one sentence, cutting lecture 5’s slides 9 and 17, running its glossary hunt in class, cutting lecture 6’s slide 19 to its three cards, folding lecture 7’s slide 15 into slide 14, giving its slide 19 one sentence, adding its span-schema part, folding lecture 8’s slide 14 into slide 13, dropping one question of its exercise, assigning lecture 9’s explainer before class, giving lecture 10’s slide 16 one sentence and dropping one question of its exercise, assigning lecture 11’s explainer before class and cutting its slide 22 to the title, shortening lecture 12’s slides 16, 17 and 25, shortening lecture 13’s slides 22 and 36, its premortem, and lecture 2’s explainer and traced run. The minutes I assign to each move are mine. The explainer in lecture 1 runs about three and a half minutes by the file’s account, and I budget four.
I attach no attention-span rule to these splits. The longest single segment of lecture in the thirteen timing tables is 19 minutes (lecture 5, slides 20 to 26), and the next longest is 17, in the same lecture. A review of the literature by Bradbury, of which I read the abstract only, concluded that “the available primary data do not support the concept of a 10- to 15-min attention limit” (Bradbury, 2016).
For the wider question of who such a course suits and why it avoids a single vendor, see the companion post on teaching AI agents to computer science students.
What line do you print when you reuse the slides?
The kit names one attribution line for these AI agents lecture slides, and CC BY 4.0 asks for three things around it. The license deed says: “You must give appropriate credit, provide a link to the license, and indicate if changes were made.” It also says you may do so in any reasonable manner, as long as the manner does not suggest the licensor endorses you or your use.
The deed permits copying and redistributing the material “in any medium or format for any purpose, even commercially”, and adapting it on the same terms. CC BY 4.0 carries no non-commercial and no share-alike condition.
This is the kit’s own line, as the hub prints it:
From the teaching kit of AI Agents, Engineered by Enrique Gutiérrez, CC BY 4.0, aiagentsengineered.com/teach/
The end slide of each deck carries the same words, opening “Slides from the teaching kit”, and prints the license address, creativecommons.org/licenses/by/4.0/, on the line below. If you present an unmodified deck, the line and the link are already on it. If you paste the line somewhere else, add the link to the license yourself.
For slides you have changed, the line needs a changes note. No file in the kit prints an adapted variant, so the wording below is this post’s suggestion:
Adapted from the teaching kit of AI Agents, Engineered by Enrique Gutiérrez, CC BY 4.0, aiagentsengineered.com/teach/. Changes: [say what you changed, for example "slides 5 and 25 removed; examples replaced"]. License: https://creativecommons.org/licenses/by/4.0/
People who reuse slides ask for this clarity. One forum poster, facing a slide notice that named two different sets of terms, wrote: “Can we get some clarification on what is the intended license?” (ixfd64, 4 March 2024). An issue on a university course repository asked for “organization, course, author names and license footer on each slide” (hmitaso, 30 September 2019).
The deed describes itself as a highlight of the license with no legal value of its own. The legal code is the license. Nothing here is legal advice.
What should you do the week before you teach?
Open the deck with its notes, run the activity once, settle the reading, and place the attribution line.
- Open the HTML deck with
?notesand read the presenter notes for the slides built to be answered by the room. - Run the activity’s browser tool once on the machine you will project from.
- For lecture 3, print or post the seven-definition handout and check that slide 24’s link opens the linter with the set loaded.
- For lecture 4, check that the links on slides 9 and 27 open both tools with their inputs loaded, and test the explainer’s sound.
- For lecture 5, check that slide 27’s link opens the calculator with its inputs loaded, and leave whiteboard room for each team.
- For lecture 6, check that both links on slide 27 open their tools with the inputs loaded.
- For lecture 7, check that both links on slide 27 open the viewer’s samples, and paste the two printed traces into the viewer once.
- For lecture 8, check that the exercise’s five links open with their numbers and that the judge link fills all three boxes.
- For lecture 9, check that the explainer plays with sound and that the exercise links open their tools filled in, and publish who attacks whom in the red team.
- For lecture 10, check that the exercise links open with their numbers and that the harness grid shows its five controls with the dials set.
- For lecture 11, check that the explainer plays with sound and that the four exercise links open with their numbers.
- For lecture 12, check that
tickets.csvdownloads from the lecture page and that the calculator link opens with its matrix filled in. - For lecture 13, check that the workshop links open filled in, and tell every team the demo schedule, its slot and its panel a week ahead.
- Choose the timing: the 80-minute table, the 75-minute or 90-minute variant, or your own split.
- Decide the reading given what is free, and tell students which parts are in the full book.
- Place the attribution line; if you changed slides, use the adapted wording and say what changed.
How do the thirteen lectures fit the thirteen-week syllabus?
The thirteen decks of AI agents lecture slides are weeks 1 to 13 of a thirteen-week syllabus, one per week, with the same titles the syllabus gives those weeks. The course is complete: every week has a deck, a lecture page and its exercises.
All eight labs the syllabus plans now have handouts: Lab 1 with lecture 2, Lab 2 with lecture 3, Lab 3 with lecture 4, Lab 4 with lecture 5, Lab 5 with lecture 6, Lab 6 with lecture 7, Lab 7 with lecture 8 and Lab 8 with lecture 10. Lectures 9, 11, 12 and 13 have no required lab: their out-of-class work is a red-team homework, a homework on the project’s own cost, latency and step meters, and the capstone, which ends in lecture 13’s demo day. Lecture 12 adds an optional, unnumbered lab on the ticket classifier. The project proposal is set with lecture 6 too.
A six-week professional short course is also mentioned in the syllabus, built from weeks 1, 2, 7, 8, 9 and 11. All six of those weeks now have decks.
For the reasoning behind the week order, see the post on the AI agents course syllabus, which covers sequencing and assessment. The dependency argument, topic by topic, is in the post on an agentic AI curriculum.
What are the limits of this kit?
These AI agents lecture slides cover the whole syllabus, but several things an instructor might expect are absent.
- No notes in the PDF. Presenter notes exist only in the HTML deck.
- No slide-software file. Editing means HTML, or rebuilding slides in your own tool.
- Reading after week 1 is mostly in the full book. Week 2’s is partly free: Chapter 3 and Appendix A are in the full book. Week 3’s, Chapters 4 and 5, week 4’s, Chapters 6 and 7, week 5’s, Chapters 8 to 10, week 6’s, Chapters 11 to 14, week 7’s, Chapter 15, week 8’s, Chapter 16, week 9’s, Chapter 17, week 10’s, Chapter 18, week 11’s, Chapters 19 and 20, week 12’s, Chapters 21, 22 and 26, and week 13’s, Chapters 23, 24, 25 and 27, are all in the full book.
- Timings are a plan. The files report no classroom trial. Lecture 3’s notes say its exercise was first timed with five more minutes than the 80-minute plan gives it.
- The cohort advice is one author’s judgment. The files give no per-lecture prerequisites.
Where to go next
Start with lecture 1, because everything it uses is free to read: the Preface, Chapter 1, “What Is an Agent?” and the first three sections of Chapter 2. Open the deck, press N, and judge the notes for yourself. Chapter 3, “The Agent Loop” supplies the second half of lecture 2 and is in the full book; you can see the formats on the home page.
Questions readers ask
- Where can I get the AI agents lecture slides, and in what format?
- Each lecture has a page under aiagentsengineered.com/teach/lectures/ (01 to 13) with two buttons: one opens the HTML deck, the other a PDF. The HTML deck carries presenter notes on every slide. The PDF has one slide per page and no notes. There is no slide-software file.
- Can I reuse and modify the slides in my own course?
- Yes. The decks state CC BY 4.0 on the title slide, in the footer of every slide between it and the end slide, and on the end slide. The license deed permits copying and adapting for any purpose, and asks you to give appropriate credit, provide a link to the license, and indicate if changes were made.
- Do the slides come with speaker notes?
- Yes, in two places. Every slide of every deck has presenter notes, shown by pressing N in the HTML deck. Each lecture page also has written instructor notes: how to run the session, an 80-minute timing table, a list of common misconceptions with a response to each, and the exercises with acceptance criteria.
- Do students need to buy the book to follow the thirteen lectures?
- For lecture 1, no: its reading is the Preface, Chapter 1 and the first three sections of Chapter 2, all free online. Lecture 2’s reading is partly free (Chapter 2, sections 4 to 6) and partly in the full book (Chapter 3 and Appendix A). Lecture 3’s reading, Chapters 4 and 5, lecture 4’s, Chapters 6 and 7, lecture 5’s, Chapters 8 to 10, lecture 6’s, Chapters 11 to 14, lecture 7’s, Chapter 15, lecture 8’s, Chapter 16, lecture 9’s, Chapter 17, lecture 10’s, Chapter 18, lecture 11’s, Chapters 19 and 20, lecture 12’s, Chapters 21, 22 and 26, and lecture 13’s, Chapters 23, 24, 25 and 27, are in the full book.
- How is the last week run, with the capstone demonstrations?
- Lecture 13’s page gives two schedules by number of teams. The recommended one runs the 80-minute lecture session and holds the demonstrations in their own sessions, in slots of twelve minutes, or ten for large classes. With five teams or fewer, one 80-minute slot holds a short lecture path, the demo briefing and five demonstrations.
Answer keys, quizzes and exam questions.
The free instructor pack has what can't sit on a public page: reading quizzes with keys, an exam question bank with worked answers, reference solutions to the labs, a capstone grading rubric, and the slide sources to edit. You get the link as soon as you confirm your email; it grows with every new lecture.
Sources
- Creative Commons (2013). Attribution 4.0 International (CC BY 4.0): the deed (read 7 October 2026)
- Creative Commons (2013). Attribution 4.0 International (CC BY 4.0): the legal code, which is the license itself
- Neil A. Bradbury (2016). Attention span during lectures: 8 seconds, 10 minutes, or more? Advances in Physiology Education 40(4), 509–513, DOI 10.1152/advan.00109.2016
- ixfd64 (DeepLearning.AI community) (2024). Forum thread: Conflicting copyright information on Coursera (4 March 2024)
- hmitaso (GitHub) (2019). GitHub issue 50, geospatial-modeling-course: license and author footer on each slide (30 September 2019)
- stevenbedrick (Hacker News) (2010). Hacker News comment on slides as visual aid versus slides as notes (9 October 2010)