Module 6 of 10

Automation & scheduled tasks.

Module 6 is the first time in the course an agent runs when you are not in the room. The directing muscle from Modules 3 through 5 transfers: read, categorize, draft, review. What changes is the control surface. A scheduled task fires on its own clock, against its own inputs, into its own artifact — and you review it later, if at all. That changes everything about how you design it. Module 6 installs the five moves every scheduled task makes (plan, trigger, run, deliver, log), the load-bearing safety norm of the module (audience = only you), the four reliability rails that keep a long-running task honest (idempotency, cost ceiling, next-review date, retirement trigger), and the retirement ritual (disable, revoke, archive) that prevents automation from quietly accumulating. You will run five scheduled tasks end-to-end — a daily morning brief, a weekly report, a research refresh, a watcher, and one you design yourself — and freeze the sixth capstone artifact of the course: automation-register-v1.md.

Recipe Book status for this module

Module 6 is a mix of CORE and RECIPE — Cowork-tab scheduled-task walkthroughs (primary), with the Claude Code CLI + an OS scheduler (cron / launchd / Windows Task Scheduler) wired in as Optional Advanced for terminal-comfortable students, plus the Gmail and Calendar scope reuse from Module 5 and the retirement procedures (disable-revoke-archive) across every backend. Every recipe in this module was last verified 2026-04-17 and is on the next-review queue for 2026-07-17. When your Cowork-tab task editor has a different field layout, your cron job fires in a zone you didn’t expect, or a launchd plist rejects a key you used — flag it. Those drift reports are what keep the quarterly refresh honest.

CORE blocks (the five moves in 6.1, the idempotency-key discipline in 6.2, the ISO-week-and-diff-contract shape in 6.3, the response-test-and-non-event discipline in 6.4, and the observability-floor and retirement-ritual in 6.5) are tool-agnostic and will still be true when Cowork looks different, when cron is replaced by something newer, and when launchd keys have been renamed. They are the durable part of Module 6.

Lessons in this module CORE + RECIPE

Work through these in order. Each lesson ends with a project checkpoint that adds one row to your automation register draft; Lesson 6.5 freezes the register after the retirement ritual and the student-designed task.

  1. 6.1   What a scheduled agent actually is.

    Mostly CORE

    The mental-model lesson of Module 6. Scheduled vs. on-demand, the five moves every scheduled task makes (plan, trigger, run, deliver, log), the idempotency-key discipline (a tag that keeps a task from doing the same work twice if it accidentally fires more than once), and the load-bearing safety norm of the module: audience = only you. Every task in this module writes to your own machine, your own drafts folder, or a private channel you are alone in. No downstream human gets an artifact unless you put it there yourself. You set up the ~/ai-architect-academy/automation/ folder and draft the register header block.

    Open Lesson 6.1 →

  2. 6.2   Your daily morning brief.

    CORE + RECIPE

    The first scheduled task of the course. A daily brief that lands in your own folder every morning — five sections, tagged with today's date so it never writes the same brief twice, honesty rails against “three items to fill the list.” Recipe walkthrough for the Cowork tab (primary), with the Claude Code CLI + cron / launchd / Windows Task Scheduler path collapsed as Optional Advanced for terminal-comfortable students. Runs three days, and you keep a three-day retrospective that goes into the register’s Notes field. Files register entry 1.

    Open Lesson 6.2 →

  3. 6.3   Weekly reports and scheduled research refreshes.

    CORE + RECIPE

    Two scheduled tasks with different rhythms and a shared concern: making sure the task stays useful instead of becoming another unread email. The weekly report’s evidence-link rail keeps the Shipped section provable. The research refresh’s diff contract — include / exclude / what counts as new — prevents the “everything is new every week” drift that kills refresh tasks. The weekly report is tagged by ISO week so it only writes one report per week; the refresh is tagged by run timestamp with a latest pointer file for easy lookup. Files register entries 2 and 3.

    Open Lesson 6.3 →

  4. 6.4   Alerts and watchers.

    CORE + RECIPE

    The conditional kind of scheduled task — one that runs every interval but only fires when a specific event is detected. The response test (if you cannot name the specific action you will take within an hour, do not build it), the condition-and-threshold-and-non-event statement, quiet-run discipline (one log line, no artifact), and an event-ID tag that keeps the watcher from firing twice on the same real event. Plus the bias question (false positive or false negative — pick one). Pairs with the Signal-vs-noise drill, which rates 12 candidate watchers against the response test. Files register entry 4.

    Open Lesson 6.4 →

  5. 6.5   Reliability, cost, and retirement (capstone freeze).

    Mostly CORE

    The discipline lesson. The observability floor every live task meets (header block, log line, next-run expectation), the four-level failure-mode hierarchy (transient / input / output / catastrophic), cost as a rate (per-run × runs-per-month, not per-session), the five retirement signals (named event, stale last-success, silent drift, ceiling breach, human-attention bankruptcy), and the three-step retirement ritual (disable, revoke, archive). You design and run register entry 5 yourself and freeze /capstone/automation-register-v1.md — the sixth capstone artifact of the course — with at least one retired row and both safety norms pasted verbatim at the bottom.

    Open Lesson 6.5 →

Module wrap-up

End-of-module check.

Ten questions across 15 points — six multiple choice, two short-answer, two applied. Closed-book for the recall sections; open-workstation for the applied pair, where you diagnose and redesign a misfiring watcher, then apply the retirement ritual end-to-end on a specific task including a written post-mortem. Passing bar: 11.5 / 15 with full credit on at least one applied question. The parent scoring summary makes it straightforward to document as a module assessment on a transcript.

Open the end-of-module check →

Resources for this module RECIPE

Seven printable companions and one interactive activity run alongside the lessons. Each printable is a print-to-PDF page that prints cleanly on letter paper. Use them in the order their lessons reference them.

  • Automation register — row template — printable for Lesson 6.1. The header block (copy once into automation-register-v1-draft.md) and the row template (copy once per task), plus the seven rules the register enforces and one fully worked example row. The scaffold that grows across all five lessons into the capstone artifact.
  • Morning brief — prompt template — printable for Lesson 6.2. The full prompt block for register entry 1: five-section output contract, scope, voice, honesty rails, delivery, log. Plus the fill-in checklist and the three-day retrospective prompt that goes into the register’s Notes field.
  • Weekly report — prompt template — printable for Lesson 6.3. The prompt block for register entry 2, with the evidence-link rail on the Shipped section. ISO-week idempotency, a specific first-run checklist you run against last week’s data before you save the task on a schedule.
  • Research refresh — prompt template — printable for Lesson 6.3. The prompt block for register entry 3, with the diff contract (include / exclude / what counts as new), the source cadence rule (read every source every run), zero-state behavior, and three example diff contracts for different topic types (court case, legislative bill, fast-moving technical topic).
  • Signal-vs-noise drill — interactive HTML activity for Lesson 6.4. Twelve candidate watchers rated against the three-way rubric (signal / adjustable / noise), with reveal-on-submit scoring that names which part of the response test each candidate failed. The rep that installs the “if the action isn’t real, don’t build the watcher” muscle.
  • Watcher design worksheet — printable for Lesson 6.4. The seven-section worksheet a watcher passes before it runs: response test, condition-and-threshold-and-non-event, quiet-run behavior, event-ID strategy, bias statement, register-entry fields, pre-launch checklist. Design the watcher completely before you write a line of prompt.
  • Retirement ritual — printable for Lesson 6.5. The per-entry block you run against every live task (cost reconciliation, five-signal check, idempotency audit, prompt integrity, decision, redesign path, three-step retirement), the aggregate checks (total monthly cost, total weekly review time, zombie tokens), and the three honest closing questions.
  • Student-designed task — planner — printable for Lesson 6.5. The ten-section planner for the scheduled task you design yourself (register entry 5): choose, why, five moves, idempotency, cost, observability, failure modes, prompt draft, register-entry fields, two-run test plan, pre-launch checklist.

What you should have when this module is done CORE

By the time you close out Module 6, you should be able to point to six concrete things on your machine and in your capstone folder:

  • A populated ~/ai-architect-academy/automation/ folder on your machine with five live subfolders — briefs/, reports/, research/q-<your-id>/, watchers/<your-watcher>/, and the folder for your student-designed task — each containing real artifacts from real runs, plus a log.txt with at least a week of log lines.
  • Each of the five scheduled tasks configured in the Cowork tab (or, for terminal-comfortable students who chose the Optional Advanced path, in cron / launchd / Windows Task Scheduler driving the Claude Code CLI) with a real trigger, a real credential scope, and a real cost ceiling. Not a file sitting on your desk. A task that fires on its own clock.
  • A completed retirement ritual artifact saved as /capstone/automation-artifacts/retirement-ritual-<date>.md covering every live entry, with at least one entry honestly marked Retired and the three-step ritual (disable, revoke, archive) completed on it.
  • A frozen /capstone/automation-register-v1.md containing, in order: a one-paragraph reflection from the retirement ritual, six rows (entries 0–5 plus at least one retired row with post-mortem), and both safety norms (drafts, not sends from Module 5 and audience = only you from Module 6) pasted verbatim at the bottom.
  • An automation suite that respects its ceiling — total monthly cost across all live tasks is under the number you set in the header block, total weekly review time is bounded by the budget you wrote into your Automation Posture, and you can name the retirement trigger for every live row from memory.
  • The completed end-of-module check in your portfolio, scored at 11.5 / 15 or better with full credit on at least one applied question.

If any of these is missing, go back to the checkpoint that produced it and finish before moving on. Module 7 assumes scheduled automation is already habitual — the custom skills and plugins it introduces are the same discipline applied to reusable building blocks.

Coming next

Module 7 — Extending AI (skills & plugins).

You’ve written prompts. Now you reach for the shape above prompts — skills that make a workflow reusable, plugins that bundle capability, and the custom-vs-off-the-shelf decision you make every time you notice yourself typing the same setup twice. Module 7 turns the scheduled-task discipline of Module 6 into durable, shareable building blocks.

Begin Module 7 once the Module 6 portfolio is complete — the six items above, including the end-of-module check.

Open Module 7 →