1. What changes from 101
101 taught students to understand AI. 102 teaches them to operate it, and that shifts your job in three ways:
- From answers to systems. Students stop producing insights and start producing artifacts that run: workspaces, skills, automations, eval suites. Your verification moves from "can you explain this?" to "does it work, and can you defend every gate in it?"
- From caution to governed autonomy. Several units hand AI real reach (files in Unit 04, connected accounts in Unit 07, standing automations in Unit 08). The safety content is not garnish; it is the spine. Facilitating these units badly is the one way this course can cause real harm, so sections 4 and 5 are mandatory reading.
- From standalone units to one accumulating toolkit. Every 102 unit produces a component the later units reuse. A student who skips Unit 01's workspaces is underequipped by Unit 08. Guard the throughline (section 3).
The 101 rule still governs everything: never re-explain what the unit explains. You coach, frame, run the room, verify artifacts, and safeguard.
2. The cohort at a glance
Prerequisite: 102 is written to stand alone (Unit 00 re-onboards), but students arrive far stronger if they did 101 or are comfortable with everyday AI use. Screen for baseline comfort; a total AI novice will struggle in Unit 04 onward.
Pace: 12 units over 8 weeks (map below) or a 12-week term. Unit 07 and the Unit 12 capstone need the most room.
| Week | Units | Session focus |
|---|---|---|
| 1 | 00 + 01 | Orientation and the workspace foundation; everyone builds three workspaces |
| 2 | 02 + 03 | Model routing and the research relay; the benchmark gets built and first reused |
| 3 | 04 | Terminal agents, full session, the safety trio is rehearsed live |
| 4 | 05 + 06 | Harnesses and earned autonomy |
| 5 | 07 | The three keys, full session, the deepest and most safety-critical unit |
| 6 | 08 + 09 | Automations that run, and art direction |
| 7 | 10 + 11 | Local models and eval suites; capstone chosen |
| 8 | 12 + showcase | Staying frontier, and the two-week capstone presentations |
Note the capstone is two weeks of real operation. Kick it off no later than the start of week 7 so it can run 14 days before the showcase. In an 8-week cohort, the capstone overlaps weeks 7 and 8; plan for it in your calendar from day one.
Session template: unchanged from 101, but the "artifact showcase" slot grows more important each week, because artifacts now feed forward. Have students physically open last week's artifact at the start of each session; they will need it today.
3. Guarding the toolkit throughline
102's artifacts chain. Post this dependency map where you can see it, and never let a student arrive at a unit missing its inputs:
| Unit | Produces | Reused in |
|---|---|---|
| 01 | Three workspaces + portable instruction blocks | 03, 04, 05, and every unit after |
| 02 | Personal benchmark + model policy | 10, 11, 12 |
| 03 | Verified research relay | 08 |
| 04 | Folder instruction file + safety trio habit | 06, 08 |
| 05 | A packaged skill | 08, 11 |
| 06 | Checkpoint policy + post-mortem habit | 08, 11, 12 |
| 07 | Connector permission policy | 08, 12 |
| 08 | One running automation | 11, 12 (becomes the capstone spine) |
| 09 | Brand board + visual pipeline | capstone (optional) |
| 10 | Local-vs-frontier verdict | 12 |
| 11 | Ten-case eval suite | 12 |
Practical rule: the first ten minutes of most sessions is "open last week's artifact." A student who lost it rebuilds it before today's unit, or pairs with someone who has theirs. The benchmark (Unit 02) and the automation (Unit 08) are the two that hurt most if missing; watch those especially.
4. The safety-critical units (read before teaching them)
Three units hand real capability to AI. Your facilitation is the difference between a rehearsed safety reflex and an actual incident.
Unit 04, terminal agents. The risk is real file loss (the unit's own Replit case study is exactly this). Enforce the trio in the room, physically: no student runs an agent on original files, everyone snapshots first, and everyone performs one rollback before leaving. The rollback is not optional; a student who has not undone something has not done the unit. Pre-run the install on the room's setup yourself; terminal installs vary by operating system and school-locked machines may block them (have the Gemini CLI free path and a paired-observation fallback ready).
Unit 07, the three keys. The risk here is conceptual becoming real: students will be tempted to connect everything to make a cool demo. The unit's discipline (never let private data, untrusted input, and outbound action touch in one system) must govern the room. When students do the key-audit on their real accounts, some will find a live trifecta they built during a past trial; treat that as the unit succeeding, help them break one key on the spot, and do not let anyone leave a newly-connected outbound-plus-private-plus-public system running. This is the unit where "it's just a demo" is the dangerous sentence.
Unit 08, standing automations. The risk is something running unsupervised and wrong. Enforce the three obligations before any automation is allowed to persist: a log, a loud failure, and a rehearsed kill switch. And enforce the platform-policy point: anything that posts to a real platform must respect that platform's automation and AI-disclosure rules, with a human gate. A student automating real posts without a gate is building the exact thing this course argues against; send them back to the unit's own warning callout.
Across all three: the gates, snapshots, and missing keys are not bureaucracy to teach around. They are the content. A facilitator who helps a student bypass them to save time has inverted the course.
5. Running live agents and connectors
Everything in the 101 guide's "nondeterministic AI" section applies, plus:
Agents make real changes, so rehearse reversibility first, every time. Before any unit where AI acts (04, 06, 08), the room's first action is establishing the undo: the snapshot, the copy, the kill switch. Ritualize it: nothing runs until the undo is proven.
Connectors touch real accounts. In Unit 07, students audit their own connected apps. Keep this to inspection and tightening; no student should connect a new sensitive account during a workshop for demo purposes. The Studio examples let you demonstrate the risky shapes without anyone risking real data.
Local models and hardware (Unit 10). The room will split by device capability. Have the browser-based path ready (the unit provides it) so phone-only and locked-laptop students complete the benchmark and write the verdict without owning the hardware. The unplugged-Wi-Fi moment is worth doing on at least one capable machine at the front of the room even if not everyone can.
Free-tier reality is heavier in 102. Deep research (Unit 03), agents (Unit 04), and video (Unit 09) have stingy free limits. Spread across tools, stagger the heavy runs, and lean on the Studio worked examples (which you can pre-run once and show) when caps hit mid-session.
6. Unit-by-unit run notes
Unit 00, Start Here. Not a teaching unit; a setup session. Get every account working, post the ground rules, explain the Studio (demonstration only; challenges are the student's own life), and land the one ethic: delegate the work, never the learning. Check: everyone can open at least one assistant and has read the free-path promise.
Unit 01, From Chats to Systems. Produce: three workspaces + portable blocks. The foundation; do not rush it. Run: the "what do you remember about me?" audit is a strong opener; have volunteers share their junk drawer (screening for anything private first). Check: three live workspaces, blocks saved outside any tool, one stated memory decision each.
Unit 02, The Right Brain for the Job. Produce: benchmark + policy. Run: the extraction-versus-schedule contrast (identical output cheap, divergent output on the hard task) is the whole lesson; do both live. Emphasize the benchmark is built once and reused all course; a thin benchmark now weakens Units 10 to 12. Check: a stored, rerunnable benchmark and a five-line policy a peer could apply.
Unit 03, Research Like a Team of Ten. Produce: the verified research relay. Run: The Handoff debuts; make it explicit that this move (one tool's output into the next) recurs every remaining unit. Spend the discussion on the load-bearing-claims idea; students want to verify everything or nothing, and the skill is triage. Check: three claims chased to primary sources, a decision defensible claim by claim.
Unit 04, The Terminal Isn't Scary. See section 4. Produce: reorganized folder + one rehearsed rollback. Run: the terminal intimidates; the "what's in this folder?" opener defuses it in thirty seconds. The payoff moment is the rollback (400 files snapping back); build to it. Check: a reviewed diff and a successful rollback, both actually performed.
Unit 05, Inside the Harness. Produce: a packaged skill passing a cold-session test. Run: the harness-inspector on this very platform is the demo; students find it genuinely surprising. The "read the car before you ride" probe on a stranger's custom bot lands well. Check: a four-part skill a fresh session follows without explanation.
Unit 06, Let It Run. Produce: checkpoint policy + post-mortem. Run: the checkpoint sandbox (place gates, run fault days) is excellent as a compete-against-yourself exercise; project the interruption-count-versus-caught-errors tradeoff. The obedience test (does the agent honor a STOP?) surprises students. Check: five tasks classified by reversibility with justified autonomy rungs.
Unit 07, Give It Your Keys. See section 4; the deepest unit, full session. Produce: connector permission policy. Run: the injection sandbox (three keys, watch the hijack, break it three ways) is the spine; run it before any discussion. The real-account key audit is powerful and must stay at inspect-and-tighten. Check: a complete key inventory, one real permission tightened, a policy naming the missing key per system.
Unit 08, While You Sleep. See section 4. Produce: one running (or one-tap) automation with governance. Run: draw-before-you-build on paper first; the build sandbox second. The "Studio assembled" case study is where students see their whole toolkit click together; pause on it. Check: a live-or-one-tap system with log, loud failure, and kill switch all demonstrated.
Unit 09, You're the Art Director Now. Produce: brand board + one governed production cycle. Run: the Kalshi ratio (hundreds generated, fifteen kept) reframes "AI art is cheating" into "selection is the job"; open with it. Generate-wide-select-narrow works as a whole-room exercise. Keep the never-real-people rule and disclosure front and center. Check: a board with a NEVER list, a taste log across a full batch.
Unit 10, Your Own Private AI. See section 5 for the device split. Produce: local-vs-frontier verdict. Run: the unplugged moment at the front of the room; the benchmark rerun against a local model makes the capability gap real and measured, not asserted. DeepSeek R1 is taught as history deliberately (the unit says so). Check: a benchmark scorecard and a dated verdict naming sensitive-by-default categories.
Unit 11, Break Your Own Stuff. Produce: ten-case eval suite catching one real finding. Run: converting a Unit 06 post-mortem "diverged" line into an eval case shows the toolkit compounding. The hostile case reuses the Unit 07 sandbox; make the connection explicit. Celebrate the first caught regression; that is the unit's whole product. Check: ten cases including one hostile, two dated runs, one single-variable change with its result.
Unit 12, Stay Frontier + capstone. Produce: the quarterly review file and the two-week capstone. Run: quarter-zero as a live pass down the seven instruments; students see their whole toolkit has become a maintenance practice. The collaboration callout ("operating together is the next ladder") sets up any 103. Capstone: 14 days of real operation, kicked off in week 7, presented at the showcase; the mandatory closing question is "what in this is yours, that you could rebuild with every AI turned off?" Check: a charter, 14 days of logs, two suite runs, and a defended continue/revise/sunset verdict.
7. Tricky moments (beyond the 101 set)
"Why not just connect everything? It's more powerful." This is the Unit 07 conversation and it will recur. The answer is the three keys: power without a missing key is a liability, and every serious system in the course is deliberately missing one. Make the student name the missing key.
A student wants to skip the safety steps to build faster. The most important redirect in this course: the gates, snapshots, and missing keys are the skill, not an obstacle to it. A fast system you cannot undo or govern is the failure mode, not the achievement. The Unit 04 and 06 case studies (Replit, Project Vend) do this argument for you.
A student lost an earlier artifact and is stuck. Expected; see section 3. Rebuild it or pair. Do not let them limp forward without the input; the units genuinely depend on each other.
"My automation works, can I remove the gate now?" No, and it is Unit 12's capstone quiz for a reason: success is when the guardrails earned their keep, never evidence they are unneeded. A caught incident is the system working.
A student builds something genuinely risky (real posting, real data, real spending) without governance. Pause it in the room. Walk them back to the relevant unit's warning callout. This is exactly the harm the course is designed to prevent, and catching it live is the most valuable teaching moment you will get.
8. Appendix A: study cohorts
Everything in the 101 guide's Appendix A applies unchanged (consent via invite code, silent instruments, ungraded quizzes, per-session fidelity log, equal treatment across arms, same-day incident reporting). Two additions specific to 102:
- Artifact-based fidelity. Because 102 produces concrete artifacts, artifact completion per unit is a clean, low-burden fidelity signal; the platform's impact dashboard already tracks challenge-checkbox completion. Nothing extra to collect.
- The construct-fit caveat, restated for the study lead. The AILIT-S instrument maps most directly onto 101's conceptual content. A 102-only cohort may sit near ceiling on parts of AILIT-S at baseline, since operators tend to arrive AI-literate; the operator-specific skills (governance, reversibility, key management) are only partly captured by that instrument. Confirm the measurement plan accounts for this before treating a flat AILIT-S delta as a null result, and consider whether the optional confidence-triad self-ratings and the artifact-completion data carry more of the 102 signal.