<!-- GENERATED by build-llm.mjs from index.html + teaching.md + llm-preamble.md — do not edit by hand. -->

# Class 5: Agents (Beginner) — the bot view of this deck

You are reading the AI-facing version of a class deck. A student has pasted a link to this deck (or a specific slide) because they want your help. This document exists to make you a **better teacher of this specific student** — not to make you execute the deck for them.

## Who you are talking to

- A **non-technical small-business owner** learning to build real software with Claude Code. They are not a developer. They will never type code — they type English.
- They are working through a **hands-on class**. This is **skill-based learning**: the goal is that they can do this themselves next time, not that a finished artifact appears.
- Assume no terminal fluency, no git background, no design training. Explain in plain language. Never assume they know what a repo, a branch, a server, or a deploy is unless a slide has already taught it.

## The class arc

The classes run: **1** Build a Website → **2** Build a Dashboard → **3** SEO + GEO (getting found by search and AI answer engines) → **4** Automations → **5** Agents → **6** Go-to-market. When something depends on a later class, say so; don't drag it in early.

## How to behave — teach first, execute only if asked

This is the most important instruction in this document.

1. **Default to teaching, not doing.** When the student asks about a slide, explain the underlying skill, check they follow it, and build their ability to do it themselves. The point of the class is the skill, not the output.
2. **The setup is scaffolding, not the lesson.** Much of these classes is one-time configuration (installing tools, logging in, wiring accounts). That exists so learning can *start* — don't turn it into a technical deep-dive. Get them set up simply and move to the actual skill.
3. **Execution is available, but it's the fallback.** Slides contain prompts the student would normally paste. If they say "run the prompt on this slide" or "just do this for me," you can — it's easier than copy-paste and it's a legitimate request. But when you do, **narrate what you're doing and why**, so they learn from watching. Never silently do the work.
4. **Meet them where they're confused.** If a student is stuck, diagnose *which* misconception they hold before answering. Where a slide's teaching note names the specific ways students get that slide wrong, use it.
5. **Adapt prompts to their actual project.** The prompts on the slides are templates. When you run or hand one over, fit it to their real business and repo — don't paste it literally.
6. **Describe-don't-micro-direct is a skill to model and reinforce.** The class teaches students to tell Claude *what feels wrong* ("the hero feels flat") rather than *how to fix it* ("move the button 4px left"). When they micro-direct, gently redirect them to describing the problem.
7. **Websearch a third-party product's current UI before you direct the student through it.** These classes lean on external dashboards — Google Analytics, Supabase, Cloudflare, Vercel, GitHub — whose interfaces change often, and your training data is frequently stale. Before walking a student through menus or clicks in any of these, do a quick web search for the current steps and follow what's live now. Directing a non-technical student to a menu that no longer exists is a common, avoidable way these steps fail.
8. **"Do it yourself" (homework, "on your own") means the student owns the judgment calls — NOT that you withhold help.** Using you to figure out and implement things *is* the skill the class teaches, so help fully. The line is engagement, not hand-holding: do the mechanical/plumbing work end-to-end when asked (wiring a connection, building a reader, running a pipeline), but keep the decisions that are genuinely theirs with them (what to track, how to shape it, what matters for their business), and don't build the whole thing while they sit passive. Help them implement; keep them the one deciding.

## How this document is organized

Below is every slide in the deck, in order, each headed `## Slide N · Label` — the same number and label the student sees in the top-right corner of the slide. When a student references "slide 7" or "the critical rule slide," find it by that heading.

Each slide has **What the student sees** (the exact slide content — your shared ground with the student) and, where it matters, **Teaching this slide** (context the student can't see). Use the second to teach; never just recite it back. The teaching notes assume the rules above — they add only what is specific to their slide.

## Where this student is right now

The student finished Class 4: a Cowork project in the Claude app with a scheduled task that reads their accounts through connectors and writes a morning brief whose items link to their sources. Today the same project gets an agent they direct: they point at brief items ("prep me for the 2pm", "handle #2") and it looks things up and acts — drafts in Gmail, tasks filed, prep notes written. No code, no keys, no terminal. Safety rules: the agent never sends anything: in the Gmail connector settings (+ > Connectors > Manage connectors) send email is set to never and drafting is allowed, so the control is that the student reads each draft and sends it themselves. Deletes are set to never; every other action is the student's call. Teach: automation follows steps written in advance, an agent decides its own steps; project instructions are the student's (only they edit them), memory is the agent's (it writes it, they can read and delete it).

---

## Slide 1

**What the student sees on this slide:**

Class 5 · Beginner · Handing work to an agent

# Stop doing the work. Start handing it off.

Agents: give Claude your judgment and your tools, then hand it the work. It decides the steps; you keep the final say.

## Slide 2 · The finish line

**What the student sees on this slide:**

_Let's look at the end first_

## By the end of today, you hand the work off.

Your morning brief already tells you what needs you. But you still do every item yourself. By the end of class, you point at an item — "prep me for the 2pm," "draft the reply to #2" — and an agent does the work, from your laptop or your phone.

_Before today_

The brief says Dana is waiting on a revised timeline. You open the thread, check your calendar, find the task, and write the reply. Twenty minutes, one item.

_After today_

You say "handle #2." It reads the thread, checks what it needs, and a draft is waiting in Gmail for you to read and send.

Same project as the brief, same accounts. Today it gets someone who can act on it.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Show the destination before explaining anything: the student points at an item in their brief and the work gets done, with a draft waiting in Gmail for them to read and send. The contrast that sells it is time: twenty minutes of opening the thread, checking the calendar, finding the task and writing, versus one sentence. Reassure early that it is the same project and the same accounts as last class; nothing new to install. If a student didn't finish last class's brief, get that running first (even a single run is enough), because the agent works from it.

## Slide 3 · The line

**What the student sees on this slide:**

_The one idea behind today_

## An automation follows steps. An agent decides them.

Last class you wrote the steps yourself: pull these emails, pull today's calendar, sort, write. The same steps every morning, no matter what arrived. That's an automation. An agent gets a goal instead, and works out the steps once it sees what's in front of it.

_⚙️ Automation — your morning brief_

You decide the steps, in advance. It runs on a schedule and does exactly what you wrote. Perfect for a job that's the same every time.

_🧠 Agent — today's build_

It decides the steps, as it goes. You give it the goal; it picks what to look at and what to do. Needed for a job that's different every time.

 🎯

The test: can you write the steps down before you see what arrives? If yes, it's an automation — keep it one. If the next step depends on what it finds, that's a job for an agent.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The spine of the class. Automation: the student decides the steps in advance and they are the same every run (the brief). Agent: it gets a goal and works out the steps once it sees what's in front of it. The test to make them say out loud: can you write the steps down before you see what arrives? If yes, keep it an automation, because it is cheaper and more predictable. If the next step depends on what it finds, it is a job for an agent. Common confusion: "but the brief uses Claude too, so isn't it an agent?" No. Using judgment inside one step the student placed is still an automation. What makes it an agent is that it chooses the steps.

## Slide 4 · Three messages

**What the student sees on this slide:**

_Why handling the brief needs an agent_

## Same inbox, three messages, three different paths .

Look at what it takes to handle three items from one morning's brief. No single recipe covers all three — each one needs a different thing looked up before it can be answered:

_📅 "Can we move Thursday?"_

It checks your calendar for open slots, then drafts a reply offering two times.

_📎 "Following up on the proposal"_

It checks your tasks , sees the proposal is overdue, and flags it to you — only you can fix that.

_📝 "Did you see my notes?"_

It finds the doc they shared, summarizes it, and drafts a reply with your next step.

That's the difference in practice. You could never write one set of steps for "handle whatever came in" — but you can tell an agent what good looks like and let it choose.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Make the test concrete. Three items from one morning each need a different thing looked up: a reschedule needs the calendar, a proposal follow-up needs the task list (and ends in flagging it to the owner, because only they can fix an overdue proposal), a "did you see my notes" needs the shared doc. No single recipe covers "handle whatever came in." If a student asks why not just write three recipes: because tomorrow brings a fourth kind of message, and the fifth. You can describe what good looks like; you cannot list every case.

## Slide 5 · What an agent is

**What the student sees on this slide:**

_No new software — you built most of it last class_

## An agent is four things. You have three already.

There's nothing to install. Your agent lives in the same project as your brief, and it's made of four parts:

 📄 Instructions you have

Today you swap them out: who it is, how it uses your brief, and what it may do.

 🔌 Tools you have

Your connectors — email, calendar, tasks. It picks which one each job needs.

 🔒 Limits you have

Your connector permissions. Today you loosen one or two, on purpose.

 🧠 Memory new today

What it learns from your corrections, so you only teach it once.

 💡

The instructions are yours; the memory is its own. You write and edit the instructions. It writes its memory as it learns — and you can read and delete anything in it.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Demystify: an agent is instructions + tools + limits + memory, and they have three of the four from last class (instructions, connectors, and their permissions). Today they swap the instructions out in Step 1: who it is, how it uses the brief, and what it may do. Tools are the connectors; the agent picks which one each job needs. Limits are the connector permissions; today they loosen one or two on purpose. Memory is new: what it learns from corrections, kept between conversations. The distinction to plant now because it matters all class: the instructions are theirs (only they edit them); the memory is its own (it writes it, they can read and delete it).

## Slide 6 · The to-do list

**What the student sees on this slide:**

_Why last class's brief matters today_

## Your brief is now its to-do list .

You don't have to explain what's going on each morning. The agent reads the same brief you do, and every item links to where it came from — the email, the meeting, the task.

_🔗 Why the links matter_

When you say "handle #2," it follows the link to the actual thread. No copying, no pasting, no describing the situation from memory.

_📋 You still choose_

Today, nothing happens until you point at an item. You read the brief, you decide what to hand over, it does the work.

If your brief's items don't link to their sources, fix that first: tell Claude to add a link to every item, and run the brief once to check.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The brief becomes the agent's to-do list, and the links on each item are what make "handle #2" work: the agent follows the link to the real thread instead of the student describing the situation. If a student's brief items don't link to their sources, fix that first: have Claude add a link to every item in the scheduled task and run it once. Also reinforce who is driving today: nothing happens until the student points at an item.

## Slide 7 · Step 1 · Its directions

**What the student sees on this slide:**

_Swap out last class's instructions_

## Step 1 — give it its directions .

Last class, your project's instructions only said what matters for the brief. Today they become the agent's directions. Open your Morning Briefing project's instructions, replace what's there with this, and fill in the brackets:

[PROMPT — the exact text the student would paste; you can run or adapt this for their project]
> Who you are: my assistant for [my business: what I do and who my customers are]. My morning brief: each morning a brief is saved in this project. Before you act, read the newest one. When I say "#2," I mean item 2 in today's brief. Follow each item's link to the original email, meeting, or task before you act on it. What you can do: draft email replies for me to approve, file tasks, and write prep notes in our conversation. Never send an email. Never delete anything. If you're not sure, ask me. How I work: [how I sound when I write, e.g. short and friendly, signed with my first name]. [Who gets priority, e.g. clients get a same-day reply]. [What always comes to me, e.g. anything about money or contracts].

 ✏️

This is a starting point — make it yours. Edit any line to fit how your business actually works: add rules, cut ones that don't apply, change what it's allowed to do.

Then check it took: with Cowork selected in the message box, ask "Which item in today's brief should I deal with first, and why?" It should name a real item and give a reason you'd agree with.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

After Class 4 the project's instructions only say what matters for the brief. Step 1 swaps them out for the agent's directions: the student opens the Morning Briefing project's instructions, replaces what's there with the template, and fills in the brackets. The brief's scheduled task still reads these instructions to decide what matters, so if they had rules they still want the brief to follow ("anything from a client is urgent"), have them carry those over into the "How I work" part. Most of the template is the same for everyone and should stay: how it uses the brief (read the newest one first, "#2" means item 2 of today's brief, follow each item's link before acting) and what it may do (draft replies for approval, file tasks, prep notes in the conversation; never send, never delete, ask when unsure). The bracketed parts are theirs: what the business is, how they sound, who gets priority, what always comes to them. Push for specifics, the way they would brief a new hire; vague answers produce a generic assistant. The slide says to edit freely, and mean it: add rules, cut ones that don't apply, change what it's allowed to do, as long as "never send" and "never delete" stay unless they understand what removing them means. Only the student edits the instructions. Then the check: with Cowork selected, ask which brief item to deal with first and why. A good answer names a real item and a reason they'd agree with; if it can't find the brief, have it look for where the scheduled task saves briefs and read the newest one.

## Slide 8 · Step 2 · Loosen its limits

**What the student sees on this slide:**

_Last class, everything that writes was set to never_

## Step 2 — loosen its limits , on purpose.

Your directions say what it may do; these settings make sure it can't do more. In the message box, click + → Connectors → Manage connectors , then click a connector. Every action it can take has its own setting: allow it , ask you first , or never .

_✉️ Gmail — set this one first_

Set send email to never . Allow creating drafts, so it can write replies for you. Anything that deletes stays never.

_⚙️ The rest is yours_

Go through each connector and set each action the way you want it: allow what you're comfortable with, ask for anything you want to see first, never for anything you don't want it doing.

 🔒

The control is the send button. It can write the draft, but it can't send it — the draft waits in your Gmail until you read it and press send yourself.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Last class everything that writes was set to never. The directions from Step 1 say what it may do; the connector settings make sure it can't do more. Where they live: in the message box, click + → Connectors → Manage connectors, then click a connector. Every action the connector offers has its own setting: allow it, ask first, or never. The one fixed rule: in Gmail, send email is set to never. Creating drafts is allowed, so it can write replies. Anything that deletes stays never. Everything else is the student's call, connector by connector: allow what they're comfortable with, ask for anything they want to see first, never for anything they don't want it doing. The control to name: the send button. The agent can write a draft but cannot send it; the draft waits in Gmail until the student reads it and presses send. These connector settings decide what an app connection may do; keep them separate from the approval setting under the message box, which is about Claude asking before it acts.

## Slide 9 · Step 3 · Hand it work

**What the student sees on this slide:**

_The moment the class is for_

## Step 3 — hand it real work.

Pick three items from this morning's brief and hand them over one at a time. Watch how it chooses what to look at — that's the agent deciding its own steps:

- 1. "Prep me for my 2pm." → it reads the invite, finds the email thread, checks open tasks with that person, and writes you a one-page prep note right in the conversation.

- 2. "Draft a reply to #2." → it reads the thread, looks up what the reply needs, and leaves a draft in your Gmail . You read it and send it.

- 3. "Turn #4 into a task due Friday." → it writes the task with the context attached and files it on your list .

 ✅

A draft waiting in Gmail, a task on your list, a prep note ready — work you pointed at, done without you doing it.

Open Gmail and your task app and look. Seeing the draft sitting there, written the way you'd write it, is the point of the whole class.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The moment the class is for. Three directions from their own brief, one at a time: prep for a meeting (it reads the invite, the thread and open tasks, and writes a prep note in the conversation; Drive stays read-only, so it should not try to save a file there), draft a reply (it looks up what the reply needs, then leaves a draft in their Gmail for them to read and send), turn an item into a task (it files it on their list). Have them narrate what it chose to look at: that is the agent deciding its own steps, the thing that makes it an agent. Then make them open Gmail and their task app and see the draft and the task sitting there. If it does something they didn't expect, don't fix the output yet; that's the "When it gets it wrong" slide.

## Slide 10 · Step 4 · Teach it once

**What the student sees on this slide:**

_So you don't correct the same thing twice_

## Step 4 — correct it once , not every time.

It will get small things wrong: offering a Friday you never take, emailing someone who prefers a call. When it does, don't just fix the draft — tell it, and ask it to remember:

[PROMPT — the exact text the student would paste; you can run or adapt this for their project]
> Dana prefers a phone call to email for anything about timelines. Remember that.

_🧠 It saves it to memory_

Start a new conversation tomorrow and ask about Dana: it still knows. That's memory — what it learned from you, kept between conversations.

_📄 Instructions or memory?_

A rule for everyone ("money questions come to me") goes in your instructions. A fact it learned ("Dana prefers calls") goes in memory.

Look through what it has remembered now and then. If something's wrong or out of date, delete it.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

It will get small things wrong. The skill: tell it, and ask it to remember, instead of silently fixing the draft. Show the persistence: a new conversation tomorrow still knows. Then the sorting rule they will use all week: a rule for everyone ("money questions come to me") goes in the instructions, which they edit; a fact it learned ("Dana prefers calls") goes in memory, which it keeps. Encourage them to look through its memory now and then and delete anything wrong or stale; memory they never review can drift.

## Slide 11 · From your phone

**What the student sees on this slide:**

_It's in the cloud, so it's wherever you are_

## Same agent, in your pocket .

Your project isn't on your laptop — it's in your Claude account. Open the Claude app on your phone , go to the same project, choose Cowork, and hand it work between meetings.

_📱 Try it now_

From your phone: "Handle #3 from this morning's brief." Same instructions, same memory, same limits.

_⏱️ Where this pays off_

Walking out of a meeting: "Draft the follow-up to Sam — we agreed on the 15th and a revised quote." By the time you sit down, it's waiting.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The project lives in their Claude account, not on the laptop, so the same agent is in the Claude app on their phone: same project, Cowork selected, same instructions, memory and limits. Have them try it live ("handle #3 from this morning's brief") and then check the draft in Gmail on their phone. The payoff to paint: walking out of a meeting and asking for the follow-up draft, which is waiting by the time they sit down. The agent can't hear the meeting, so the request has to carry what was agreed ("we agreed on the 15th and a revised quote"); point that out. If the app's layout differs from the desktop, help them find the project first, then the Cowork toggle.

## Slide 12 · When it gets it wrong

**What the student sees on this slide:**

_A mistake is information_

## When it gets it wrong, fix the cause .

Fixing the draft fixes today. Fixing the cause fixes every day after. First ask it "why did you do that?" — then fix the right thing:

_📄 A rule was missing_

It didn't know how you handle this kind of thing. Add it to your instructions.

_🧠 A fact was wrong_

It believed something that isn't true. Correct it and have it update its memory.

_🔒 It could do too much_

It tried something it shouldn't be able to. Tighten that permission.

Describe what went wrong, not how to fix it. "That reply was too formal for a client I've known for years" teaches it more than rewriting the email yourself.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

A mistake is information. Fixing the draft fixes today; fixing the cause fixes every day after. First ask it "why did you do that?", then fix the right layer: a missing rule goes in the instructions, a wrong fact gets corrected in memory, and an action it shouldn't have been able to take means tightening that permission. Reinforce describe-don't-micro-direct: "that reply was too formal for a client I've known for years" teaches it more than rewriting the email themselves.

## Slide 13 · What it still waits for

**What the student sees on this slide:**

_The honest limit of today's build_

## It still waits for you to ask .

Today's agent is capable, but it only works when you open the app and hand it something. You still read the brief first, you still decide what to hand over, and nothing happens while you're busy.

_Today_

You read the brief. You say "handle #2." It does it.

_Next class_

It reads the brief before you do , handles what you've authorized, and hands you a short list of what it did and what only you can decide.

That's the next step: not an agent that drafts while you sleep, but one that means you stop being the person who has to check.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Name the honest limit of today's build so Class 6 lands: it only works when they open the app and hand it something. They still read the brief first and still decide what to hand over; nothing happens while they're busy. Next class it reads the brief before they do, handles what they've authorized, and hands them a short list of what it did and what only they can decide. The framing to leave them with is not "an agent that drafts while you sleep" but "you stop being the person who has to check."

## Slide 14 · Homework

**What the student sees on this slide:**

_Your homework · do it this week_

## Grow it this week — your choice .

The goal before next class: an agent you trust with the work you hand it — one you rarely have to correct. Pick the direction that gets you there fastest for your business:

_🔁 Give it more automations_

Add another scheduled task to the same project — a weekly wrap-up, a Friday check on unpaid invoices, a Monday plan — so there's more for the agent to work from.

_☀️ Expand the morning brief_

Add a source, sharpen what counts as urgent, or change the sections, so the brief — and the agent's to-do list — fits your day better.

_✏️ Keep refining the agent_

Hand it items every morning. Each time you correct it, ask why, then fix the cause in your directions or its memory.

 📝

You're there when you send its drafts with barely a change. Along the way, keep one list: what you ask it to do most often. Those repeat jobs are where next class starts.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The goal before next class: an agent the student trusts with the work they hand it, one they rarely need to correct, because Class 6 hands it jobs to do without being asked and that only works on a foundation they already trust. The three directions are the student's choice of how to get there; all are valid, and they pick the one that helps their business most. (1) Give the agent more automations: another scheduled task in the same project (a weekly wrap-up, a Friday unpaid-invoice check, a Monday plan), which gives the agent more to work from; it's the Class 4 pattern again (fixed steps, exact rules, read-only), so reuse that slide's approach. (2) Expand the morning brief: add a source, sharpen what counts as urgent, or change the sections, which improves both the brief and the agent's to-do list. (3) Keep refining the agent: hand it items every morning, and on each correction ask why, then fix the cause (a rule in the directions, a fact in memory, or a connector setting). Help fully with the mechanics; the choice of direction and the judgment calls are theirs. A practical test that they've arrived: they send its drafts with barely a change, and they've stopped double-checking the tasks it files. Whatever they pick, they keep one list: what they ask the agent to do most often. Those repeat jobs are next class's starting point, the jobs the agent takes on without being asked.

## Slide 15 · You shipped it

**What the student sees on this slide:**

_That's the class — here's what you have now_

## You have someone to hand the work to.

- An agent in the same project as your brief, reading it the way you do.

- Directions that say who it is, how it uses your brief, and what it may do.

- Limits loosened on purpose — it drafts and files, and nothing goes out until you send it.

- A memory that keeps what it learns, so you teach it once.

 🔁

Next class, it stops waiting for you. It reads the brief first, handles what you've authorized, and hands you a morning handoff: what it found, what it did, and the few things only you can decide.

An automation follows your steps. An agent decides its own steps when you ask. Next: an agent that keeps watch, so you don't have to.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Recap: an agent in the same project as the brief, directions that say who it is, how it uses the brief and what it may do, limits loosened on purpose (it drafts and files, and nothing goes out until they send it), and a memory that keeps what it learns. The through-line to Class 6: it stops waiting to be asked. It reads the brief first, handles what they've authorized, and hands them a morning handoff: what it found, what it did, and the few things only they can decide. If a student asks what they actually learned, name it: telling an automation from an agent, writing down how they work, deciding what software may do in their accounts, and correcting it at the cause.
