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

# Class 4: Automations (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

This deck stands alone: do not assume the student took any earlier class. They have the Claude app on a paid plan. Today they build a "morning briefing" inside a Cowork project in the Claude app: a scheduled task that runs in the cloud (laptop open or closed), reads a few sources through connectors (email/calendar/tasks, all read-only), decides what matters using the project instructions, and writes one brief. No code, no keys, no terminal. NEW territory this class: connecting real accounts. The critical safety rules: read-only is a SETTING (connector permissions: send, delete and anything that changes an account set to never, via + > Connectors > Manage connectors), and no password or key is ever typed into the chat. Also teach the fixed-rule-vs-judgment split (write every fixed step as an exact instruction; only "what matters" is judgment) and the "Require this computer" toggle (only for sources that live on the computer).

---

## Slide 1

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

Class 4 · Beginner · Making work happen without you

# The work you do by hand, done without you.

Automations: set Claude to run the repetitive parts of your day on a schedule, so you don't have to.

## Slide 2 · The finish line

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

_Let's look at the end first_

## By the end of today, your morning runs itself.

Every morning you open the same handful of things and piece together "what actually needs me today." By the end of class, a scheduled task in Claude does that — at a time you set, before you sit down, even with your laptop closed — and hands you one short brief of what matters.

_What you do by hand now_

Open your calendar, your task list, the news, your inbox — and reassemble the day from scratch. Fifteen scattered minutes before you've done anything.

_What runs for you after today_

One task reads all of it, decides what's worth your attention, and writes a single triaged brief — done before you open your laptop .

Here's how it works: you describe what you want, Claude sets it up, you check the result. Today we point it at your own repetitive work.

## Slide 3 · What this is

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

_Why this class exists_

## An automation does the busywork — so you don't.

You already know what these are — you just do them by hand. Think about the little office jobs that eat your day and don't really need you , just your time. Each of these can run on its own:

_📥 Sort my inbox_

Instead of scanning a hundred messages every morning, it reads them and tells you the few that actually need you today .

_✍️ Draft the reply_

For the emails you answer the same way every time, it writes the reply in your words — you just read it and hit send.

_📝 Summarize the thread_

A 20-message back-and-forth becomes three lines: what was decided, and what's next — without you reading all of it.

_🔔 Chase the follow-ups_

It remembers who never replied and drafts the nudge , so you're not keeping a mental list of loose ends.

Notice what they share: each one reads something and makes a small judgment — what's urgent, how to reply, what matters. That "deciding" is the interesting part, and it's exactly what today's build does.

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

Teach the category so the whole class clicks: an automation does the busywork so the student doesn't. The examples (sort my inbox, draft the reply, summarize the thread, chase follow-ups) share one thing worth naming — each READS something and makes a small JUDGMENT (what's urgent, how to reply, what matters). That "deciding" is the interesting part and exactly the one step today's build leaves to Claude. If a student thinks automation means "rigid robotic macros," reframe it: the value is the judgment step, not just moving data around.

## Slide 4 · The thing itself

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

_What lands in front of you_

## The morning briefing — one screen, already sorted.

Here's what the task produces. It pulls from the places your day actually lives, and instead of dumping raw lists, it uses judgment to sort the signal from the noise — because reading everything is the chore we're removing.

_☀️ Your brief, 7:00am_

Needs you today: the two calendar events that actually matter, the one task that's overdue, the client email worth a reply.

Worth a glance: a headline about your industry, three tasks that can wait.

Handled / noise: everything it decided you can safely ignore.

Every item links to the email, meeting, or task it came from.

_Why it feels different_

It's not a raw feed — it's a decision . Something read all of it and told you where to look first. That "what matters" call is the part only judgment can do, and it's the one step you leave to Claude's judgment.

It reads, but never touches: it never sends, deletes, or moves anything in your accounts. It briefs you — you stay in control of every action.

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

The morning briefing, shown — teach why it feels different from a raw feed. It pulls from where their day actually lives and, instead of dumping lists, USES JUDGMENT to sort signal from noise (needs-you-today / worth-a-glance / handled-noise). Something read all of it and told them where to look first — that's the part only judgment can do, and the one step they leave to Claude. Every item links back to the email, meeting or task it came from; mention it, because next class an agent works from those links. Reinforce the safety framing that recurs all class: it READS but never touches — never sends, deletes, or moves anything in their accounts. It briefs; they stay in control of every action. A worried student needs to hear that clearly.

## Slide 5 · The method

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

_The one move behind every automation_

## Map the steps you do by hand — then hand the map to Claude.

This is the skill you'll reuse for anything you automate, and it's the only real work you do: describe the process the way you actually do it, step by step. Then you hand that map to Claude, and Claude builds the automation around it — you're not writing code, you're describing the routine. Take your morning:

 Open your sources
 →
 Decide what matters
 →
 Write yourself the short version

 🤝

You don't have to map it perfectly alone — Claude helps you map it. Describe your routine roughly and it fills in the steps you skipped, asks about the cases you forgot, and makes sure nothing's missing before it builds. The mapping is a conversation, not a test.

That's your morning, mapped. Hand it to Claude and it sets up a task that does those steps for you — but first, one question sorts every step, and it changes how you write each one. That's the next slide.

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

The skill they'll reuse for ANYTHING they automate, and the only real work they do: map the process the way they actually do it, step by step, then hand the map to Claude — Claude sets up the automation around it. They're not writing code, they're describing a routine. The reassurance to give: they don't have to map it perfectly alone — Claude helps map it, filling in skipped steps and asking about forgotten cases. Mapping is a conversation, not a test. If a student freezes on "I don't know how to describe my process," tell them to describe it roughly and let Claude interrogate it into completeness.

## Slide 6 · The key question

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

_Ask this of every step you mapped_

## Can a fixed rule do it — or does it need judgment?

The same three-step process, filled in with real sources. Sort each step: most are deterministic — a fixed rule, one right answer — and only where a rule can't decide do you spend a judgment call. Watch how few need it:

 1 · Open your sources
 ⚙️ Fixed rule Pull today's calendar events — the same request every morning. One right answer.
 ⚙️ Fixed rule Pull your unread emails — unread, last 24 hours. Mechanical.
 ⚙️ Fixed rule Pull today's + overdue tasks — due today or overdue. Mechanical.
 ⚙️ Fixed rule Pull yesterday's dashboard numbers — read the data. Same every run.
 2 · Decide what matters
 🧠 Judgment Pick the urgent emails + what else matters — no rule tells urgent from noise. This is the AI call.
 3 · Write the short version
 ⚙️ Fixed rule Save the brief — same format, same place. Mechanical.

 🎯

Five of six steps are fixed rules. Only "what matters" needs judgment. Write every fixed step as an exact instruction (which emails, which calendar, what format) and leave Claude to decide only what no rule can. That's what makes it an automation: you decide the steps, in advance, and they're the same every morning. Two reasons: consistency (exact steps give you the same brief every run; vague ones let it wander) and cost (the less it has to figure out, the less of your plan each run uses).

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

The concept that makes automations reliable — teach it well. Ask of every mapped step: can a FIXED RULE do it (one right answer, same every run) or does it need JUDGMENT? Most steps are fixed (pull today's calendar, unread email from the last 24 hours, tasks due today); only "what's urgent vs noise" needs judgment. The discipline: write every fixed step as an exact instruction, and leave Claude to decide only what no rule can. That is the line between an automation and an agent: in an automation, the student decides the steps in advance and they never change; an agent (next class) decides its own steps. Two reasons — CONSISTENCY (exact instructions give the same brief every morning; vague ones let it wander) and COST (the less it has to figure out, the less plan usage each run takes). If a student wants to just say "give me a morning brief," this is the pushback: a vague instruction hands Claude the steps, which makes it an agent, and the brief will drift from morning to morning.

## Slide 7 · Pluggable

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

_You choose what it watches_

## Wire in the places your work actually lives .

Each app gets its own connector — a ready-made link inside the Claude app. One sign-in per app, no keys to copy, no code. Pick about three to start so we get your briefing running today; add the rest whenever you want.

 📧 Email read-only

Your unread inbox — so the brief flags what's urgent.

 📅 Calendar

Today's meetings, and what they need from you.

 ✅ Task manager

Todoist, or similar — today's and overdue tasks.

 📝 Notion

A page or database you keep your work in.

 📁 Google Drive

A doc or sheet you keep plans or numbers in.

 📊 Your dashboard

Yesterday's key numbers, if the tool you track them in has a connector.

 🔌

These six are just a start. The Claude app has a directory of connectors — if your tool is in it, connecting it is one sign-in. Everything stays read-only , and in a few slides you'll lock that in as a setting.

Why one connector per app? If one breaks, the others keep working, and adding a source never touches the rest. Next class, an agent uses these same connectors to act on your brief.

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

Teach the architecture idea and the one requirement. Each app gets its own connector — a ready-made link inside the Claude app, one sign-in, no keys to copy — so they plug in whatever's relevant to THEM. Pick ~3 to start so the briefing runs today, add more later. The one requirement for any source: it has to be in the Claude app's connector directory. If it isn't, leave it for now rather than improvising a workaround. Everything stays read-only, and a few slides later they lock that in as a setting. Why one connector per app matters (say it — it pays off next class): if one breaks the others keep working, adding a source never touches the rest, AND next class an agent uses these same connectors to act on the brief.

The bigger principle to extrapolate — teach it, because it applies to EVERYTHING they build, not just source-picking: start narrow and small, prove it works end-to-end, THEN tack things on. "Pick three sources" is one instance of a general rule. If a student tries to do too much at the start — every source, every feature, all at once — they create a huge fix-it backlog: many things broken simultaneously, and it becomes near-impossible to tell which piece failed. Whereas a narrow first version that actually runs gives them a working baseline to add to one piece at a time, testing each. So if a student wants to connect ten things at once, or pile on features before the core runs, steer them back: get the smallest working version running first, then grow it. This is the same "core first, then extend" idea as the Set-up-the-build note — this is the WHY behind it.

## Slide 8 · Runs without you

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

_The part that makes it an automation_

## It runs on a schedule — even with your laptop closed .

Nothing to install, no server to rent. Your briefing is a scheduled task : you set the time once, and Claude runs it in the cloud every morning — whether your computer is on, asleep, or packed in a bag.

 ⏰ 7:00am
 The task starts

Laptop open

 Your brief runs
 Waiting when you sit down

 Laptop closed

 Your brief still runs
 It runs in the cloud, not on your laptop

_☁️ Runs in the cloud_

 The task lives in your Claude account, not on your machine. Read it from your laptop or the Claude app on your phone — wherever you are when the morning starts.

_💻 The one exception_

If your brief needs a file that only exists on your computer, turn on Require this computer . Then it only runs while your computer is awake. Everyone else leaves it off.

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

Teach what makes it an automation, and the one exception. The briefing is a SCHEDULED TASK: they set the time once and Claude runs it in the cloud every morning, whether their computer is on, asleep or closed. Nothing to install, no server. They can read the brief from their laptop or from the Claude app on their phone. The exception worth understanding: the "Require this computer" toggle. If a source is a file that only exists on their computer, they turn it on, and then the task only runs while that computer is awake. Everyone else leaves it off. If a student asks "what if my laptop is closed?", this slide is the answer: it still runs.

## Slide 9 · The project

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

_One home for everything_

## Build it inside a project — one home for it all.

In the Claude app, a project keeps everything for one job in one place. Start a new project for your briefing — everything you build today, and next class, lives there.

_What a project holds_

Your instructions (what matters to you), the scheduled task that writes your brief, and every brief it has written.

_Why it beats a plain chat_

Claude doesn't remember yesterday's chat — but a project keeps its instructions. Every task in it reads them before it starts, every morning, so you set them once .

 💡

Why it matters here especially: next class, an agent joins this same project. It reads the same briefs and follows the same instructions — so nothing you build today gets rebuilt.

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

Teach the project as the home for the whole build. In the Claude app, a project keeps everything for one job in one place: their instructions (what matters to them), the scheduled task, and every brief it writes. Claude doesn't remember yesterday's chat, but a project keeps its instructions, and every task in it reads them before it starts, so they set them once. Why it matters especially here: next class an agent joins this SAME project, reads the same briefs and follows the same instructions. Nothing built today gets rebuilt. Make sure they create a new project for the briefing rather than working in a loose chat.

## Slide 10 · Set up the build

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

_One prompt sets up the whole build — you check it_

## Set up the whole build with one prompt.

In the Claude app, start a new project called Morning Briefing . In its message box, switch from Chat to Cowork , then paste:

[PROMPT — the exact text the student would paste; you can run or adapt this for their project]
> Set up my morning briefing as a scheduled task in this project, running every weekday at 7:00am. First, ask me which tools I want it to read (my email, my calendar, my task list, or anything else I use) and help me pick three to start. For each one, agree with me on exactly what to pull, so it's the same every morning. For example: unread emails from the last 24 hours, today's calendar, tasks due today or overdue. Each morning, pull those, decide what actually needs me using this project's instructions, and write one short brief: what needs me today and why, my day in order, who's waiting on me, and what you skipped, with one line on why for each. Every item links to where it came from. Keep each day's brief so I have a history. It's read-only: never send, reply, delete, or change anything in my accounts. Use this app's connectors to reach my accounts. If one isn't connected, walk me through connecting it. Don't require my computer unless a source only exists there.

_✋ Once it's set up — check it covered these four stages_

- 1. The connectors — one for each app you picked, each connected before it runs.

- 2. The fixed steps — exactly which emails, which days, what format. The same every morning.

- 3. The judgment step — one step that decides what matters, using your project's instructions.

- 4. Schedule + prove it — the time you chose, and one run right now so you see the brief.

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

One prompt sets up the whole automation; the student answers its questions and checks the result, and doesn't paste more steps. They create a new project called Morning Briefing, switch its message box from Chat to Cowork (the toggle under the box), and paste the prompt there. If they paste it with Chat selected, have them switch to Cowork and paste again. The prompt has Claude ask which tools they want it to read (any tool with a connector, not just email, calendar and tasks), help them pick three to start, and agree, for each one, on exactly what to pull so it's the same every morning (the email/calendar/tasks rules in it are examples, not a fixed choice). That agreement is the key-question slide in practice: "check my email" is vague; "unread email from the last 24 hours" is a fixed rule. There is no separate plan step: after they paste it, Claude asks which tools to connect and what to pull from each, then sets it up. Once it's set up, coach them to check it covers four stages: 1 the connectors (one per app they picked, each connected before it runs), 2 the fixed steps (exactly which emails, which days, what format — the same every morning; this is the key-question slide made real), 3 the judgment step (one step that decides what matters, using the project's instructions), 4 schedule + prove it (their time, plus one run now so they see the brief). If any stage is missing, or the steps are vague ("check my email"), tell Claude what to fix. If it set the task to need their computer, ask why: it should only need it when a source lives only on that computer. The discipline to reinforce hard: START WITH THREE SOURCES OR FEWER. Get the whole thing working end-to-end first, THEN add more. This "core first, then extend" rule applies to everything they build.

## Slide 11 · A new habit · Permissions

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

_Before it touches your accounts_

## Read-only is a setting , not a promise.

Connecting your accounts means Claude can reach them. So before the first run, decide exactly what it's allowed to do there. Every connector lists its actions — read, search, draft, send, delete — and each one gets its own setting: in the message box, click + → Connectors → Manage connectors , then click a connector.

_🔒 The three settings_

Allow it — it just does it. Ask you first — it checks with you. Never — it can't, even if it tried.

_✋ What to set today_

Allow the reading actions. Set send, delete, and anything that changes your accounts to never. Your briefing only reads — so reading is all it's allowed to do.

 🛡️

Never type a password into the chat. Connectors sign in through each app's own sign-in page — you never hand Claude a password. If anything ever asks you to paste a password or key into the chat, stop. And "never send" in your instructions is a request; the never setting is a lock.

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

CRITICAL SAFETY TEACH — this is the most important note in the class. Connecting real accounts means Claude can reach them, so before the first run they decide exactly what it may do there. In the message box they click + → Connectors → Manage connectors, then a connector: every connector lists its actions (read, search, draft, send, delete…) and each gets one of three settings: allow it (it just does it), ask you first (it checks with you), never (it can't, even if it tried). Today's rule: allow the reading actions; set send, delete and anything that changes their accounts to never. The briefing only reads, so reading is all it may do. Make the distinction land: "never send" written in the instructions is a request; the never setting is a lock. Keep these connector settings separate from the approval setting under the message box, which is about Claude asking before it acts. Next class they will loosen one or two of these on purpose, for drafting; today everything that writes is locked.

The second rule, enforced every time: NEVER have the student type a password or key into the chat. Connectors sign in through each app's own sign-in page, so Claude never needs one. If anything asks them to paste a password or key into the chat, they stop. If a student starts to paste one to you, STOP them and redirect to the connector's own sign-in. This is the one place in the class where a wrong move has a real security cost — hold the line firmly and explain why.

## Slide 12 · Plan step 1 · The connectors

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

_Claude sets this part up — you just sign in_

## Step 1 — connect each app you picked.

You pasted the prompt, so Claude starts setting up. First it checks each app you picked — your email, your calendar, your tasks. If one isn't connected yet, it tells you. Each connector has one job in this task: go get today's stuff from that app and bring it back.

_🙋 Your only job_

When Claude reaches an app that isn't connected, click + → Connectors in the message box, find the app, and sign in with that app's own sign-in page. Then set its permissions, exactly as on the last slide.

_🧩 Why one per app_

If your task manager's connector breaks, your calendar still works. Adding an app later means adding one more connector — nothing else changes.

If your tool isn't in the connector directory, leave it for now — start with the ones that are, and get the brief running first.

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

Teach the one-connector-per-app idea in plain words. Claude checks each app they picked; if one isn't connected yet, it tells them. Their only job: click + → Connectors in the message box, find the app, sign in with that app's own sign-in page, then set its permissions as on the Permissions slide. Why one per app: if one breaks the others keep working, and adding an app later means adding one more connector with nothing else changing. If a connector fails, test that one on its own. If their tool isn't in the connector directory, leave it for now and get the brief running with the ones that are.

## Slide 13 · Plan step 2 · The judgment

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

_The one step that needs a brain_

## Step 2 — your instructions say what "matters" means.

How does Claude know what to sort toward ? From your project's instructions : a box of plain-English rules that every task in the project reads before it starts. Every morning, the task reads them before it sorts. It's the one thing you truly shape here.

_📄 Your instructions — what it should care about_

Write what urgent means to you : "Flag anything from a client, or with a deadline today. Skip newsletters. Keep it to five lines." Change them and tomorrow's brief changes — nothing else touched. Tune them over the first few mornings until it thinks like you.

_✍️ Only you edit them_

The task reads your instructions every morning but never changes them. What matters stays your call — written down once, applied every day.

 💡

Those instructions are the seed of an agent. Today they do one job — sorting your brief. Next class, an agent in this same project follows them too, and starts keeping its own memory of what it learns from you.

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

Teach how the automation knows what "matters" — via the project's INSTRUCTIONS. Teach it from scratch, assume they've never written any: a box of plain-English rules that every task in the project reads before it starts. Every morning the task reads them before sorting. This is the ONE thing they truly shape. Teach them to write what urgent means TO THEM ("Flag anything from a client or with a deadline today. Skip newsletters. Keep it to five lines."). Change the instructions and tomorrow's brief changes — nothing else touched; tune them over the first few mornings until it thinks like them. Only they edit the instructions; the task reads them but never changes them, so what matters stays their call. The big idea to plant: these instructions are the SEED OF AN AGENT — next class an agent in this same project follows them too, and starts keeping its own memory of what it learns from them.

## Slide 14 · Plan step 3 · Deliver + schedule

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

_Send it, and set it loose_

## Step 3 — save the brief, then set the alarm.

Two small pieces to finish. Claude sets up both — you just approve when it asks.

_📄 Where the brief lands_

Each morning's brief is saved in your project , dated, so you keep a history. Open it from your laptop or the Claude app on your phone. Nothing is sent anywhere: it only reads your sources and writes the brief.

_⏰ The schedule_

Pick the time — say, weekdays at 7:00am. Leave Require this computer off unless a source lives only on your computer. The time is your only input.

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

Two small pieces, Claude sets up both, student approves. (1) Where the brief lands: each morning's brief is saved in their project, dated, so they keep a history; they can open it from the laptop or the Claude app on their phone. Nothing is sent anywhere — it only reads sources and writes the brief. (2) The schedule: they pick the time (weekdays at 7:00am is a good default) and leave "Require this computer" off unless a source lives only on their computer. Their only input is the time.

## Slide 15 · Plan step 4 · Prove it

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

_Don't assume — run it_

## Step 4 — run it once, live, right now.

The last step: don't wait until tomorrow morning to find out if it works. Run the task once now, in the room, and watch the brief appear. Then confirm the schedule so it runs on its own from now on.

- 1. Run it now → ask Claude to run the task once: it pulls your sources, sorts, and writes the brief .

- 2. Read it → does the "needs you today" list actually look right? Change your instructions, not the brief.

- 3. Confirm the schedule → the task shows when it runs next: tomorrow, at your time.

 ✅

A real brief in your project, and a schedule that runs tomorrow without you — laptop open or closed. That's a working automation.

Something off — brief empty, a source missing, a connector errored? Tell Claude exactly what you saw; it diagnoses and re-runs. That's the habit for anything you build: describe what you see, and let Claude fix it.

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

Don't wait until tomorrow morning to find out if it works — run it now, live, in the room. Three checks: (1) ask Claude to run the task once → it pulls the sources, sorts, and writes the brief; (2) read it → does "needs you today" actually look right? If not, change the instructions, not the brief, so the fix sticks for every morning after; (3) confirm the schedule shows its next run at their time. "A real brief in the project + a schedule that runs tomorrow without you, laptop open or closed" = a working automation. If something's off (brief empty, a source missing, a connector errored), describe exactly what they saw to Claude — that's the habit for anything they build. Push back on any urge to "trust it'll work tomorrow" — prove it live now, because a scheduled thing that silently fails is worse than none.

## Slide 16 · Extend it

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

_Same automation — a few more jobs_

## Things you can extend this automation to do.

Your briefing is one task, running on fixed steps. Once it works, you can add more fixed jobs — still predictable, still on your schedule, still read-only. Two easy, useful additions:

_📅 A weekly wrap-up_

A second task for Friday afternoon: what got done this week, what slipped, what's coming Monday . Same sources, same instructions, different schedule.

_📰 Watch a topic_

Add a step that searches the news for your industry or a competitor, and puts the one headline worth knowing in your brief.

 🧩

These are still the automation — fixed steps you wrote. It reads and reports; it doesn't act. The leap to something that does things for you — drafts the reply, files the task, preps the meeting — is a different thing entirely. That's Class 5.

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

Once the briefing works, they can add more FIXED jobs — still predictable, still scheduled, still read-only. Two easy adds: a weekly wrap-up task for Friday afternoon (what got done, what slipped, what's coming Monday — same sources and instructions, different schedule), and a step that searches the news for their industry or a competitor and puts the one headline worth knowing in the brief. The crucial boundary to teach: these are still THE AUTOMATION — fixed steps they wrote. It reads and reports; it doesn't act. Drafting replies, filing tasks and prepping meetings are acting on their behalf, and that's Class 5. If a student wants it to start doing things in their accounts, that's the line: today's tool is trustworthy precisely because its steps are fixed and its connectors are read-only.

## Slide 17 · When it breaks

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

_A machine you trust has to be honest_

## Make it tell you when it breaks .

An automation you rely on has one real danger: it stops working and you don't notice. A briefing that silently dies is worse than no briefing, because you've stopped checking by hand. So the last thing worth building is a brief that's honest about its own health.

_📣 It tells you when it fails_

If a connector is disconnected or a source can't be reached, the brief says so at the top — "couldn't reach your calendar this morning" — instead of quietly leaving it out.

_☀️ Silence never means "fine"_

It still writes a brief on a quiet day — "all clear, nothing urgent" — so no brief means something's wrong, never "all good." Add both to your project's instructions.

This is the difference between a toy and a tool: saying what it couldn't do, and never lying to you by staying silent. It's two lines in your instructions, and it's what makes the thing trustworthy enough to actually rely on.

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

Teach the reliability mindset — the difference between a toy and a tool. An automation you rely on has one real danger: it stops working and you don't notice, which is worse than no automation because you've stopped checking by hand. So build in honesty, as two lines in the project's instructions: (1) it SAYS when something failed — if a connector is disconnected or a source can't be reached, the brief says so at the top ("couldn't reach your calendar this morning") instead of quietly leaving it out; (2) silence never means "fine" — it writes a brief even on a quiet day ("all clear, nothing urgent"), so NO brief means something's wrong, never "all good." A small ask that makes the thing trustworthy enough to actually depend on.

## Slide 18 · Homework

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

_Your homework · do it this week_

## Plug in one more source — one that's yours .

You built it with three starter sources. Your homework: add one source that's specific to your work — the one that would make the brief genuinely yours. You've got everything you need; this is you doing it on your own.

_Pick the one that fits you_

- The one you skipped — whichever of email, calendar, or tasks didn't make your first three.

- Notion — the page where you plan your week.

- Google Drive — the sheet where you track your numbers.

_You know how_

Same pattern as today: connect the app, set its permissions , add one step to the task, then run it once to check. Read-only, done.

 🎓

No step-by-step this time. You know projects, connectors, permissions, and instructions. Adding a source is the same move you made three times today — now do it once for something only you would think to track.

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

Do-it-yourself homework — but that does NOT mean refuse to help. Walking them through it IS the skill; the class is about the student using Claude to implement things. Help them fully. The real line is engagement, not hand-holding: don't do it FOR them while they sit passive. Here the split is clean — the SETUP is fair game for Claude to walk them through (connecting the app, setting its permissions, adding the step to the task, running it once), but the DECISION is theirs: WHICH source to add — the one that makes the brief genuinely theirs (whichever of email, calendar or tasks they skipped, Notion, a Google Drive sheet, or something only they'd track). That choice is the point of the homework and no one else can make it. Reinforce it's the SAME pattern they did three times today: connect it, set permissions, add one step, run it once. Coach the pattern, help them implement, but keep the "what's worth tracking" call with them.

## Slide 19 · You shipped it

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

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

## You built something that works while you sleep.

- A scheduled task that reads your sources and briefs you every morning — laptop open or closed.

- Fixed steps you wrote , with one judgment step that follows instructions only you edit.

- Connectors locked to read-only by a setting, not a promise.

- The habit of a tool that tells you when it breaks instead of going quiet.

 🧠

Next class, you get someone to hand the work to. An agent joins this same project. It reads your brief, you tell it what to handle — "prep me for the 2pm," "draft the reply to #2" — and it does the work.

An automation follows steps you wrote, on a schedule. An agent decides its own steps toward what you ask. Same project, same brief — now with someone to hand the work to. That's Class 5.

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

Recap slide. Reinforce what they now have: a scheduled task that briefs them every morning with the laptop open or closed, fixed steps they wrote with one judgment step following instructions only they edit, connectors locked to read-only by a setting, and a brief that tells them when it breaks. The through-line to next class: an agent joins this SAME project, reads the brief, and they tell it what to handle ("prep me for the 2pm," "draft the reply to #2"). The distinction to leave them with: an automation follows steps you wrote, on a schedule; an agent decides its own steps toward what you ask. If a student is proud but unsure "what was the point beyond a morning email," name it: they learned to map a process, split fixed rules from judgment, lock down what software can do in their accounts, and build something reliable that runs without them — the foundation for real agents.
