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

# Class 6: The Loop (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 Classes 4 and 5: a Cowork project with a scheduled task that writes a morning brief, directions in the project instructions, and connector settings that let the agent draft in Gmail and file tasks (Gmail send email set to never). Today the agent stops waiting to be asked: a second scheduled task at 7:30 reads the brief first, acts within authority the student writes down (handle / prepare / bring to me / leave alone), checks its own work, keeps a Handoff log in the project, and writes a morning handoff. No code, no keys. For unattended runs, connector actions are set to allow or never, not ask. Send stays never; the student sends their own drafts. Promise: delegating vigilance. The daytime hourly check is optional and uses plan usage.

---

## Slide 1

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

Class 6 · Beginner · Letting it keep watch

# Stop checking. Start getting the handoff.

The loop: your agent reads the morning before you do, handles what you've authorized, and hands you only what needs you.

## 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 wake up to a handoff .

Right now your morning starts with a list of things that need you, and you hand them over one at a time. After today, the agent has already been through that list before you sit down.

_Your brief today_

"Sarah needs the revised timeline." Now you have to open the thread, write the reply, and send it.

_Your handoff after today_

"Sarah needed the revised timeline. I drafted the reply — it's in your Gmail. Two things only you can decide: the Acme discount, and whether to move Friday."

Same project, same brief, same agent. Today it stops waiting for you to ask.

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

Show the destination: a handoff instead of a brief. The brief says "Sarah needs the revised timeline"; the handoff says the reply is already drafted in Gmail, and names the two things only the student can decide. The point to land is not the draft, it's that the student didn't have to notice. Reassure that nothing is rebuilt: same project, same brief, same agent.

## Slide 3 · The shift

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

_Three classes, one thing off your plate each time_

## It tells you. You tell it. Now it does it.

Each class took one more job off your hands. Today's is the one you didn't know you were doing: being the person who checks.

_⚙️ Class 4 · Automation_

A schedule starts it; you wrote the steps. It reads everything and tells you what needs you. You still do the work.

_🧠 Class 5 · Agent_

You start it; it decides the steps. You read the brief, point at an item, and it does the work.

_🔁 Class 6 · The loop_

A schedule starts it; it decides the steps. It reads the brief first, does what you've allowed, and hands you the rest.

 🎯

You're delegating vigilance. The valuable thing isn't that it can draft an email while you sleep. It's that you stop being the one who keeps checking whether an email needs drafting.

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

The three-class arc as one picture. Class 4: a schedule starts it, the student wrote the steps, it reports. Class 5: the student starts it, it decides the steps, it acts. Class 6: a schedule starts it and it decides the steps, so it reads first and hands over the rest. The phrase to leave with them is "delegating vigilance": the value isn't drafting while they sleep, it's no longer being the person who checks whether something needs drafting. If a student asks how this differs from Class 4 (both run on a schedule): who decides the steps. The brief follows fixed steps; the loop decides what each item needs.

## Slide 4 · The loop

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

_The idea behind every agent that "keeps an eye on things"_

## Look, decide, act, write it down — again .

An agent that seems to keep watch isn't doing anything magic. It runs the same loop over and over, and each time it starts by looking at what's changed.

 Look
 →
 Decide
 →
 Act
 →
 Write it down
 →
 Look again

_You've built most of it_

Class 4 built look : the brief. Class 5 built decide and act , with you starting it. Today closes the loop, so it can start the next round itself.

_⏰ A schedule starts it — nothing more_

"Every morning at 7:30" says when to look . It doesn't say what to do. What it does depends on what it finds.

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

Demystify "proactive." An agent that seems to keep watch is running the same loop repeatedly: look, decide, act, write it down, look again. Class 4 built look (the brief), Class 5 built decide and act with the student starting it, and today closes the loop so it starts the next round itself. The second idea: a schedule starts the loop but doesn't dictate the work. "7:30 every morning" says when to look; what it does depends on what it finds. That is the difference from the brief, whose steps are fixed.

## Slide 5 · Authority, not a script

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

_What makes it safe to let it run_

## Give it authority , not a script.

You can't list every case it will meet. What you can do is say, for each kind of thing, how far it may go on its own:

 ✅ Handle it

Do it and tell me after. Filing a task, putting prep notes in the handoff.

 ✍️ Prepare it

Get it ready, and I finish it. A reply drafted in Gmail that I read and send.

 🙋 Bring it to me

Only I can decide. Money, contracts, a client who's upset.

 🚫 Leave it alone

Don't touch it. Newsletters, receipts, anything from my bank.

 🎯

The goal isn't "never involve me." It's "only involve me where my judgment is actually needed." Everything else, it should handle, prepare, or leave.

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

The core design idea. They can't list every case, so instead of steps they give it authority: for each kind of thing, how far it may go alone. Handle it (do it and report after), prepare it (get it ready and the student finishes it, e.g. a Gmail draft they read and send), bring it to me (only the student can decide), leave it alone. Use "bring it to me," not "needs approval," so it isn't confused with connector settings. The goal line: not "never involve me" but "only involve me where my judgment is actually needed."

## Slide 6 · Step 1 · Its authority

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

_Added to the directions you wrote last class_

## Step 1 — write down how far it may go .

Open your Morning Briefing project's instructions and add this section below your directions. Fill in the brackets with your own examples:

[PROMPT — the exact text the student would paste; you can run or adapt this for their project]
> When the handoff task runs (on your own, while I'm away): Handle yourself: [e.g. file a task for anything with a deadline; put prep notes for today's meetings in the handoff]. Prepare for me: [e.g. draft replies to scheduling requests and simple questions; leave them in Gmail for me to send]. Bring to me: [e.g. anything about money or contracts, or a client who sounds upset]. Leave alone: [e.g. newsletters, receipts, anything from my bank]. If you're not sure, don't act — bring it to me in the handoff.

 ✏️

Start with what you already trust. Use your list from last week — what you asked it to do most. The jobs on it that it gets right go under "Handle" or "Prepare." Anything you still correct stays under "Bring to me" for now.

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

They add a "When the handoff task runs" section under the directions they wrote in Class 5, with four lists (handle, prepare, bring to me, leave alone), their own examples in the brackets, and a closing rule: if unsure, don't act, bring it to me in the handoff (there's no one to ask at 7:30). Scoping it to the handoff task by name matters: every task in the project reads the instructions, and the 7:00 brief must stay read-only and fixed. Tie it to last week's homework list (what they asked it to do most): the jobs on it that it gets right go under handle or prepare; anything they still correct stays under bring to me. Prep notes go into the handoff itself, since Drive stays read-only. Starting conservative is correct; they widen it as trust grows. Push for concrete kinds of things ("scheduling requests," "invoices over $1,000," "anything from Acme"), not vague ones ("important emails").

## Slide 7 · Step 2 · No one watching

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

_When it runs on its own, nobody is there to answer_

## Step 2 — check its limits for when you're away .

Open + → Connectors → Manage connectors again. Last class you could answer "ask you first" in the moment. At 7:30 in the morning, you won't be there.

_⚙️ Allow or never_

For every action the handoff task uses — reading, creating Gmail drafts, filing tasks — pick allow . For actions you never want, like deleting, pick never .

_✉️ Send stays never_

Send email is still set to never. That's what makes "prepare" safe: it can leave a draft, but it can't send it. The send button stays yours.

"Leave alone" is about kinds of messages, so it lives in your instructions, not here — these settings are per action. And "ask you first" still works when you're directing it yourself; it just isn't a setting to rely on while you're not there.

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

When the loop runs at 7:30, nobody is there to answer "ask you first," so for every action the handoff task uses (reading, creating Gmail drafts, filing tasks) they choose allow in + → Connectors → Manage connectors, and never for actions they never want, like deleting. Don't let them try to enforce "leave alone" here: it's about kinds of messages, and connector settings are per action, so setting Gmail reading to never would break both the brief and the handoff. "Leave alone" lives in the instructions. Send email stays never; that's what makes "prepare" safe, because it can leave a draft but cannot send it. "Ask you first" still works when they direct it themselves; it just isn't a setting to rely on for unattended work. Keep connector settings (what the app connection may do) separate from the approval setting under the message box (Claude asking before it acts).

## Slide 8 · Step 3 · Its log

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

_So it doesn't rediscover the world every morning_

## Step 3 — give it a log of what it did.

Each run starts fresh. Without a record, it would draft the same reply twice or forget what's still waiting on you. So it keeps a running log in the project. Add one more line to your instructions:

[PROMPT — the exact text the student would paste; you can run or adapt this for their project]
> Keep a running log in this project called "Handoff log": what you handled, what you prepared, what's waiting on me, and what changed since your last run. Read it at the start of every handoff run, and update it before the run finishes.

_📒 What the log is for_

It's how it knows "I already drafted that" and "that's still waiting on you since Tuesday." It's also how it notices what changed .

_👀 It's yours to read_

Open it any time to see exactly what it did and when. If something in it is wrong, tell it — it fixes the log and learns from it.

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

Each run starts fresh, so without a record it would draft the same reply twice or lose track of what's waiting on the student. The fix is a running "Handoff log" in the project: what it handled, what it prepared, what's waiting on the student, what changed since the last run, read at the start of every handoff run and updated at the end (scoped to the handoff task, so the brief doesn't touch it). This is also how it notices change, which the daytime check depends on. The log is the student's to read; if something in it is wrong, they tell the agent to fix it. If a run can't find or update the log, that's the first thing to troubleshoot: ask it where it saved the log and have it confirm it read the latest version.

## Slide 9 · Step 4 · The handoff task

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

_A second scheduled task, right after the brief_

## Step 4 — schedule the handoff .

Keep your morning brief exactly as it is — it's still the automation. Add a second scheduled task that runs after it. In the project's message box, with Cowork selected, paste:

[PROMPT — the exact text the student would paste; you can run or adapt this for their project]
> Set up a scheduled task in this project that runs every weekday at 7:30am, after my morning brief. Each run: read today's brief and your Handoff log. For each item, follow my instructions on what to handle, prepare, bring to me, or leave alone. After anything you do, check it really happened — the draft is in Gmail, the task is on my list — and if it didn't, say so. Then write my morning handoff: what you found, what you handled, what you prepared for me, what changed since yesterday, and what needs my decision. If nothing needs me, say so. Save each day's handoff in this project, dated, so I have a history. Update your Handoff log last.

Leave Require this computer off, like your brief. The whole loop runs in the cloud.

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

The brief stays exactly as it is: it's still the automation, and keeping it fixed is the Class 4 lesson. They add a second scheduled task at 7:30, after the brief, by pasting the prompt with Cowork selected. The prompt carries three of the class's ideas: follow the authority lists, act then verify (check the draft is really in Gmail, the task really on the list, and say so if not), and write the handoff in five parts (found, handled, prepared, changed, needs your decision), saved in the project and dated like the brief, updating the log last. Leave "Require this computer" off. If the brief sometimes finishes late, move the handoff later rather than earlier.

## Slide 10 · Step 5 · Prove it

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

_Don't wait until tomorrow_

## Step 5 — run it once, and check its work .

Ask Claude to run the handoff task once now. Then check it the way you'd check a new assistant's first morning:

- 1. Read the handoff → does "needs my decision" contain only things that really need you?

- 2. Open Gmail's drafts and your task list → is everything it says it did actually there?

- 3. Open the Handoff log → does it match what happened?

 ✅

A handoff, drafts waiting, tasks filed, and a log that matches — tomorrow it does this before you wake up.

 🔍

Don't take its word for it. An agent can say "I created the draft" even when the draft didn't save — a connector hiccup, the wrong thread. So after it acts, the task looks for each draft and task it made, and tells you in the handoff if one is missing. Check too, until you trust it.

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

Run it once now, and check it like a new assistant's first morning: does "needs my decision" contain only things that really need them; is everything it says it did actually in Gmail and the task list; does the log match. Name the principle: act, then verify. "I created the draft" isn't a draft existing, which is why the task checks its own work and why the student checks too until they trust it. If something's off, describe what they saw to Claude and fix the cause (usually the authority lists or the task prompt), then run it again.

## Slide 11 · Tune what reaches you

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

_The first week is calibration_

## Tune what it brings to you .

Your first few handoffs will be off in one direction or the other. Fix it in your instructions, by moving kinds of things between the four lists — not by editing the handoff.

_📥 It brings you too much_

You keep seeing things you'd have handled the same way every time. Move that kind of thing to Handle or Prepare .

_🤐 It decides too much_

It handled something you'd have wanted to see. Move that kind of thing to Bring to me , and tell it why.

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

The first week is calibration, and the handoff will be off one way or the other. Too much reaching them: things they'd have handled the same way every time, so move that kind of thing to handle or prepare. Too little: it handled something they wanted to see, so move it to bring to me and say why. The fix always goes in the instructions (the four lists), not in editing the handoff, so it sticks for every morning after.

## Slide 12 · During the day

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

_Optional, once the morning loop has earned your trust_

## It can keep watch during the day , too.

"Proactive" just means the loop runs again. Add a check every hour or two: it looks at what's changed since its last run, acts if something did, and updates your handoff.

_🔁 What that looks like_

"The 2pm moved to 3pm. I updated the prep in your handoff and flagged the conflict it creates at 3:30." You didn't have to notice.

_⏱️ It checks — it doesn't get notified_

It can't be told the instant something changes. It finds out the next time it looks. Checking hourly means your handoff catches up within the hour.

 📊

Checks during the day use your plan. Watch Settings → Usage for a few days. If you hit limits on Pro, check every few hours instead of hourly, or move to Max, where you're unlikely to hit them.

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

Optional, once the morning loop has earned trust. "Proactive" is just the loop running again: a check every hour or two looks at what changed since the last run (using the log), acts if something did, and updates the handoff. Be honest about the mechanism: it can't be notified the instant something changes; it finds out the next time it looks, so hourly means within the hour. Usage: daytime checks use their plan. They should watch Settings → Usage for a few days; if they hit limits on Pro, check every few hours instead of hourly, or move to Max, where they're unlikely to hit them.

## Slide 13 · Read the handoff

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

_Your new morning habit_

## Read the handoff, not the inbox .

You're no longer reviewing everything that arrived. You're reviewing what changed, what it did, and what's still yours.

_☀️ Silence never means "fine"_

It writes a handoff every weekday morning, even a quiet one: "Nothing needs you today." No handoff on a weekday means something broke — check the task's last run.

_📒 Skim the log weekly_

Once a week, read what it handled on its own. It's the fastest way to spot a habit you don't like before it becomes a problem.

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

The new morning habit: read the handoff, not the inbox. They review what changed, what it did, and what's still theirs. Two habits keep it trustworthy: silence never means fine (it writes a handoff every weekday, even a quiet one, so no handoff on a weekday means something broke and they check the task's last run), and a weekly skim of the log to catch a habit they don't like before it becomes a problem.

## Slide 14 · Where this goes next

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

_A tour, not homework_

## There's a bigger version of what you built .

Claude Managed Agents runs agents on Anthropic's own cloud. You set them up in the Claude Console (platform.claude.com), and its menu is made of parts you already know:

 🤖 Agents

The agent itself: its instructions, its tools, and which tools run on their own or ask first. In the app: your directions, connectors, and connector settings.

 💬 Sessions

Each run of an agent, kept so you can watch it work, read what it did, and step in. In the app: a conversation or one scheduled run.

 ⏰ Deployments

Runs on a schedule, timed to the minute, with a dollar cap on each run. In the app: scheduled tasks.

 🖥️ Environments

The cloud computer it works on: what's installed and which websites it can reach. In the app: handled for you.

 🔐 Credential vaults

The keys and sign-ins for its tools, stored so it can use them but never see them. In the app: signing in to connectors.

 🧠 Memory stores

What it keeps from one session to the next. In the app: memory and your Handoff log.

 🚀

Start with Quickstart. It builds your first agent with you and lets you test it in a chat window before it ever runs on its own. It's in beta and billed separately from your Claude plan: its own API key, charged by use, plus $0.08 an hour for the time it's actually working.

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

A tour, not homework, and it should stay a tour: nobody builds this in class. The slide follows the Managed Agents section of the Claude Console menu (platform.claude.com), so students can match it to what they'll see: Quickstart, Agents, Sessions, Deployments, Environments, Credential vaults, Memory stores. Explain each through what they already built. Agents: the agent's definition (model, system prompt, tools and MCP servers, skills, and a permission policy per tool: always_allow, always_ask, or auto, where the server decides per call) — in the app, their directions, connectors and connector settings. There is no "never" policy: to stop a tool entirely you disable it on the agent, which is the equivalent of the app's never. Sessions: each run, with its full history kept; you can watch it, read it and send it a message mid-run — in the app, a conversation or one scheduled run. Deployments: scheduled runs on a cron schedule, down to the minute, with an optional dollar budget per run — in the app, scheduled tasks. Environments: the cloud sandbox configuration, meaning installed packages and network access — the app handles this for them, which is part of why the app is simpler. Credential vaults: stored credentials for MCP servers (OAuth or tokens) and environment-variable secrets that are swapped in at the moment of a request, so the agent uses a key without seeing it — in the app, signing in to connectors. Memory stores: persistent memory mounted into sessions — in the app, memory plus the Handoff log. Quickstart: the Console's guided builder with a built-in test session, the right place to start. Be honest about moving up: it's in beta, it needs its own API key billed by usage (separate from their Claude plan), and session runtime costs $0.08 per session-hour, counted only while the session is running (not while it's idle or waiting). Most students never need it; the point is knowing the ceiling exists and what each part is called.

## Slide 15 · What it opens up

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

_Why you'd move up_

## What it can do that the app can't .

 ⚡ Webhooks

A webhook is a web address another service calls the moment something happens — a form sent, a payment made. With a tool like Zapier making that call, your agent starts right then, not at the next check.

 🔌 Any app with an API

Not just the connector directory: any service with an API or an MCP server. Its key is stored so the agent can use it but never see it.

 💻 Its own computer

Every run gets a cloud workspace where it can run scripts, crunch spreadsheets, and install tools.

 👥 A team of agents

One agent hands pieces of a big job to others and combines what they send back.

 🎯 A definition of done

Give it a checklist for a good result, and it keeps working until the result passes.

 💰 Exact schedules, hard caps

Runs timed to the minute, and a dollar limit on each run it can't go past.

 🧑‍🏫

Claude can teach you the rest. Ask it: "Walk me through rebuilding my morning handoff as a Claude Managed Agent." Paste in your directions, and it will guide you through the Console step by step.

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

What Managed Agents adds, each in plain words. Webhooks: define the term first (a web address another service calls the moment something happens, like a form submission or a payment). Be precise about the mechanics if asked: Managed Agents doesn't hand you such an address directly; something has to make the API call that starts a session when the event happens, typically a tool like Zapier's or Make's webhook step, or a little code. (Managed Agents' own "webhooks" feature is the other direction: it notifies you when a session starts, idles, hits its budget or ends.) Any app with an API: any service with an API or a remote MCP server, not just the connector directory; credentials live in a vault and are substituted at the moment of the request, so the agent can use a key without ever seeing it. Its own computer: each session gets a cloud sandbox with a shell, packages and files. A team of agents: a coordinator can hand threads of work to other agents. A definition of done: a rubric it iterates against until the result passes. Exact schedules and hard caps: cron schedules to the minute, and hard dollar budgets per session or per scheduled run. The closing move matters most: they don't need a class for this, because Claude can walk them through it. Have them ask Claude to guide the rebuild of their handoff as a Managed Agent, pasting in their directions; Claude should check the current docs before directing them through the Console, since it's a beta product whose UI changes.

## Slide 16 · Homework

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

_Your homework · keep it going_

## Run it for a week, then pick the next chore.

For the next week, start every morning with the handoff. Tune the four lists as you go. Then, when it runs without surprises, point the same skills at something new.

_This week_

- Read the handoff first, every morning.

- Move things between the four lists as you learn.

- Turn on a daytime check once mornings feel right.

_Then: the next chore_

Map one more job you do by hand. Ask the Class 5 question: can you write the steps before you see what arrives? Then decide: an automation, something you direct, or something it watches for you?

 🎓

No step-by-step this time. You know how to automate a routine, hand work to an agent, and give it authority to act on its own. The next chore uses the same moves.

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

A week of starting every morning with the handoff and tuning the four lists, turning on a daytime check once mornings feel right. Then the next chore: map one more job they do by hand and ask the Class 5 question (can you write the steps before you see what arrives?) to decide whether it's an automation, something they direct, or something it watches for them. Help fully with the mechanics; the choice of chore and where it sits are theirs.

## Slide 17 · You shipped it

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

_That's the course — here's what now runs_

## You stopped being the one who checks .

- A morning brief that reads your accounts on a schedule.

- An agent that acts on it when you ask, from your laptop or phone.

- A loop that reads the brief first, does what you've authorized, and hands you the rest.

- Limits you set on purpose: nothing is sent until you send it.

 🔁

It tells you. You tell it. It does it. That's the whole arc — and it works for any chore where you can say what "handled" means.

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

Close the course, not just the class. What now runs: the brief (automation), the agent they direct, the loop that reads first and hands over the rest, and limits set on purpose, with nothing sent until they send it. The arc to leave them with: it tells you, you tell it, it does it, and it works for any chore where they can say what "handled" means. If a student asks what they actually learned: telling an automation from an agent, writing down their judgment, giving software authority with limits, and checking its work until they trust it.
