# Assignment 3 — Configure an Agent Workflow

**Released after:** Session 3 · Agents, Harnesses & Skills
**Do it during:** the Wed–Thu build period (or right after Session 3)
**Time:** ~45 min · **Tools:** Claude; Claude Code recommended for the full version

## Why this matters

If a skill *adds* context, an **agent** *subtracts* it: you hand a fresh worker a clean
window and one scoped task. You reach for a new agent when you want **isolation** (the
worker shouldn't be swayed by the whole conversation that led here), an **adversarial
check** (an independent reviewer that won't rubber-stamp its own work), or **parallel
scope** (several independent pieces running at once).

This assignment makes that real, and it drills the two field rules from Session 3:

> **Never trust that the agent did what you asked. Never trust that it did what it *said*
> it did. Verify by side effects you can observe.**

## What to do

Pick **one** track.

### Track A — Claude Code (full version)

1. Choose a small, self-contained task with a *checkable* result — e.g. "summarize every
   `.md` file in this folder into a single index," or "find every place we mention the old
   product name and list them."
2. Delegate it to a **sub-agent** (a scoped task with its own context) rather than doing it
   inline. Notice what you had to *tell* it — because it knows nothing about your
   conversation so far.
3. **Verify by side effects.** Don't accept the agent's summary of what it did. Open the
   files. Check the list against reality. Find at least one thing it got wrong or skipped.
4. Now use the **adversarial** pattern: ask a *second*, fresh agent to review the first
   one's output and try to find errors. Compare what the reviewer caught.

### Track B — Web app (no terminal)

1. Take a task with two genuinely separate phases — e.g. **draft** a vendor-evaluation memo,
   then **critique** it against your procurement checklist.
2. Do the draft in one conversation. Then open a **brand-new conversation** and paste *only*
   the draft and the checklist — nothing else — and ask it to critique. This new chat is
   your "agent": a clean window, no memory of how the draft was made, so it can't defend it.
3. Notice how the independent critique differs from asking the *same* chat to review its own
   work. That difference is the whole point of spinning up a separate agent.

## Deliverable

- A one-paragraph description of the task and how you scoped it.
- **What you had to pass in** for the fresh agent to succeed — and one thing you *forgot*
  to pass that it therefore couldn't know. (This is the core lesson: an agent only knows
  what you tell it.)
- One concrete error you caught by **verifying side effects** rather than trusting the
  agent's self-report.
- Two sentences: where in your org an *isolated* or *adversarial* agent would be worth more
  than a single all-knowing assistant.

## Safety note

If you experiment with an always-on or unrestricted harness (Session 3's OpenClaw):
**do not run it on your personal machine or with access to anything you can't afford to
lose.** Use a clean VM or a throwaway account. One of these agents in the wild deleted its
own version-control directory.

## Going further (optional)

- Run three reviewer agents on the same output and take a majority vote. Did consensus beat
  any single reviewer?
- Hand the same task to two agents with *different framings* (e.g. "be fast" vs. "be
  thorough") and compare.