All tracks — 4 hours, drop-in friendly

Agentic Workflows: Automating the Boring Parts Without Losing Control

Design a supervised agent workflow — one that does your most repetitive production chore with human checkpoints at every irreversible step — and learn exactly which parts of your practice should never be automated.

▶ HTML Slides

01This Week at a Glance

You will make: an agent workflow spec (steps, tools, risks, checkpoints) + an Automation Boundary Map for your real practice.

1 · Concepts (40 min)

Agent vs chatbot vs workflow; tool use as risk surface; the checkpoint; the four safety rails.

2 · Concepts (15 min)

The Automation Boundary Map; what makes a good agent task.

3 · Demo (35 min)

An agent organizes a messy folder — plan-then-act, the rejection, the audit.

4 · Lab + share (105 min)

Your boundary map + workflow spec; critique swap finds the missing checkpoint.

The week in one line

Automate friction, never judgment — and put a human at every door that doesn't open backwards. An agent is an extremely fast intern with no judgment and no stake in the outcome. The whole week is one discipline: delegating without abdicating.

02Key Concepts

1 · Agent vs. chatbot vs. workflow

	Chatbot	Workflow	Agent
What it does	Answers	Runs fixed steps you defined	Decides its own steps
Control	You drive each turn	You wrote the path	It picks the path
Best for	Thinking, drafting	Predictable repeated tasks	Messy, variable tasks
Risk	Low	Low–medium	Higher — it can surprise you

Most "agentic" creative work is actually a workflow (predictable, safe) with one or two agentic steps. You don't need a robot; you need a reliable assembly line with a human inspector.

2 · Tool use is where capability and danger both live

An agent's power comes from tool use — operating other software. Every tool is a capability and a risk surface. The rule: give the smallest access that does the job. Broad access is how "organize my folder" becomes "email my drafts to a client."

3 · The checkpoint: where you stay the director

The thesis

Plan first, act second. Make the agent propose its plan and stop for approval before touching anything. The non-negotiable: a checkpoint before every irreversible action — sending, deleting, publishing, paying, overwriting. Twenty seconds of reading a plan and killing one bad line is the whole difference between delegating and abdicating.

4 · Safety rails (design these in, every time)

Never delete — move ambiguous things to /_review.
Run on copies until trusted. Your only copy is sacred.
Changelog everything — every action and every uncertainty.
Flag uncertainty, don't guess — "if unsure, skip and report."

Watch out

An agent will invent a decision you never gave it — a naming rule, an alt-text guess, a "this is probably the final." The changelog and /_review folder are how you catch those. Read the log.

5 · The Automation Boundary Map

AutomatePure friction; repeatable, reversible, taste-free (renaming, alt-text drafts, export checklists).

AssistAI helps but a human decides every time (the best cut, the client email, the final crop).

Human-onlyYour authorship and relationships — the concept, the art, the client trust. An empty column here is a warning sign.

6 · Good agent tasks

Batch renaming · alt-text drafting · folder packaging · social cut-down checklists · contact sheets · QA checklists · admin scaffolding. The pattern: structured, repetitive, reversible, verifiable. Not all four? It wants assist, not automation.

03This Week's Words

AgentAn AI that acts: breaks a goal into steps, uses tools, checks work, continues.

Tool useAn agent operating other software. Capability = risk surface.

Workflow automationWiring a repeatable multi-step process to run with minimal supervision.

Human-in-the-loopA person reviewing at designed points. Delegating vs. abdicating.

Checkpoint / approval gateA designed stop — mandatory before irreversible steps.

Plan-then-actAgent proposes its plan and waits for approval before touching anything.

Safety railsNever-delete, run-on-copies, changelog, flag-uncertainty.

ChangelogThe agent's log of every action + uncertainties. Your accountability trail.

Scope (of access)What an agent is allowed to touch. Smallest that works.

Boundary mapAutomate / assist / human-only — sorted by reversibility and authorship.

Full course glossary →

04Demo: An Agent Does Production Chores (Supervised)

I made this, so can you

An agent organizes a real-feeling messy folder — on a copy — with a brief that demands plan-then-act.

Prepared demo artifact

Instructor backup / finished example: messy-folder agent-run/CHANGELOG.md agent-run/QA-CHECKLIST.md agent-run/alt-text.md. Use it if the live tool run fails, or to reveal the finished structure after critique.

Plan first. "Propose a folder structure and naming convention — STOP and show me before touching anything."
The checkpoint moment. The instructor rejects one element of the plan out loud and approves the rest. Twenty seconds; the whole week's thesis.
The run, with rails. Rename and organize (never delete; ambiguous → /_review), draft alt-text.md, build QA-CHECKLIST.md, write CHANGELOG.md.
The audit. Open the changelog and /_review. Find where it decided something it wasn't told — and which of those decisions would have hurt on a real client job.

The planned failure

It misclassifies at least one ambiguous file or invents a slightly-wrong alt text — caught by the rails. That catch is the point: we plan, log, and quarantine instead of trust.

05Step-by-Step Workflows

Designing a safe agent workflow

Pick a chore that's structured, repetitive, reversible, verifiable.
Write the inputs — and the permission status of anything not solely yours.
List the AI steps, each with the smallest tool access that works.
Place the checkpoints — minimum one before anything irreversible; note what you check and what makes you reject.
Add the safety rails — never-delete/_review, run-on-copy, changelog, flag-uncertainty.
Define verification — how you confirm it worked this run.
Run on a copy. Read the changelog. Then trust it a little more.

The Automation Boundary Map (15 min, revisit forever)

List 10–15 real recurring tasks.
For each: reversible? repeatable? taste-free? whose material?
Sort into Automate / Assist / Human-only.
The "automate" column is your agent candidates; "human-only" is your manifesto, sharpened.

06Prompt Recipes

The plan-then-act brief (the core move)This folder is [what it is — a finished project for client X]. Plan first, act second. Step 1: propose a folder structure and a file-naming convention for this project — STOP and show me before touching anything. After my approval: rename and organize all files (NEVER delete; move anything ambiguous to /_review), draft alt text for each image into alt-text.md, build QA-CHECKLIST.md for handoff, and write CHANGELOG.md logging every action and anything you were unsure about.

The scope-tightening clauseConstraints: work only inside this folder. No internet access. No deletions — ever. Don't overwrite originals; if a name collides, append a version suffix. If you're unsure about any file, skip it and note it in CHANGELOG.md rather than guessing.

The boundary-map sorterHere are 12 recurring tasks in my creative practice: [list]. For each, tell me: is it reversible, repeatable, and taste-free, and whose material does it touch? Then sort them into Automate / Assist / Human-only, and flag any I've miscategorized — especially anything in "automate" that actually needs my judgment.

The changelog auditor (after a run)Here is the CHANGELOG.md from an agent run: [paste]. Point out: every decision the agent made that wasn't explicitly in my instructions, which of those could cause a problem on a real client job, and what I should verify by hand before trusting this output.

The workflow critic (before you build it)Here is my draft agent workflow spec: [paste]. Find the missing checkpoint before an irreversible step, the tool access that's broader than the task needs, and the one failure that would be most expensive if it happened unnoticed. Be specific.

07Lab: Boundary Map + Workflow Spec (70 min)

Cold start friendly. No agent access? Fully fine — this lab is design work; the spec is the deliverable.

Boundary map (15 min): 10–15 real tasks → Automate / Assist / Human-only. Defend your "human-only" column to a neighbour.
Pick + spec (30 min): one "automate" task → fill the workflow spec template completely — steps, smallest access per step, a checkpoint before every irreversible action, the four rails, a verification method. ✏️ every checkpoint with what would make you reject.
Critique swap (15 min): trade specs; each finds the missing checkpoint and the over-broad access. Every first-draft spec has at least one.
Revise (10 min): fix what your partner found; note what you missed.

Zero-AI / paper track (fully equal)

The boundary map and the spec are design documents. A workflow you can't write on paper is a workflow you can't trust to a machine.

08Integrity Check

This week's four

Is there a human checkpoint before every irreversible step? (Find the one you missed.)
Does any step have broader access than the task needs? Tighten it.
Whose material does the workflow touch — and is every non-yours item permission-cleared?
If an agent touches client deliverables: the changelog is your audit trail. "Production organized by a supervised agent; all selection and client-facing decisions human."

09Troubleshooting

Problem	Fix
The agent did something I didn't ask	Read the changelog — it's logged. Tighten the brief and scope; add a checkpoint where it improvised
It deleted/overwrote something	You skipped the never-delete rail or ran on originals. Recover from your copy; the rail is non-optional
Plan-then-act gets ignored	Put "STOP and show me before touching anything" in capitals at the end — many agents respect the last instruction most
The changelog is vague	Demand specifics: "log the exact old→new name for every file and a reason for every /_review placement"
It's slower than doing it myself	Then it belongs in "assist" or "human-only," not "automate." Killing a bad automation is a correct result
I can't tell if it worked	Your spec lacked a verification step. Add one that checks this run — spot-check 3 outputs against the rules

10Resources

GuideLinkedBuilding Effective AI Agents — AnthropicThe definitive guide: workflows vs. agents, simplest-pattern-that-works, and why most "agents" should be workflows. This week's stance, from the source.
GuideLinkedWriting Tools for AI Agents — AnthropicOn tool design and scope — why a few tightly-scoped tools beat broad access. The "smallest access that works" principle, expanded.
DocsVerify before teachingClaude Code documentationThe agent tool in the demo — permissions, file access, and approval flows change; check current behaviour.
DocsVerify before teachingOpenAI Codex / Agents documentationThe other agentic toolset; verify current scope/approval model before demoing.
ReferenceLinkedThe EU AI Act explorerRe-visit from Week 1: automated decision-making and transparency obligations are tightening — relevant when agents touch client- or public-facing work.
VideoVerify before teachingA current "what is an AI agent" explainer (credible source)A short, calm explainer helps the agent-vs-chatbot distinction land for absolute beginners; pick the current best.

Optional extension

Design a second workflow for a collaborative chore (packaging deliverables for a teammate) — collaboration adds permission and disclosure questions.
Stress-test your spec: write the three worst things the agent could do if one instruction were misread, then add a rail or checkpoint for each.
Hard mode: sketch how your Week 11 tiny tool and this workflow would chain — the tool produces, the workflow packages. That's a personal pipeline (a Week 14 capstone in disguise).

Next week: Jobs, Portfolios, and Career Leverage → — turning everything you've built into the materials that get you hired, in your voice.