Section 9 of 9
Delegating to Agents
Harness, Boundaries and Accountability
How agents work and fail, how to tell them what you want, how to bound what they can do, and how to judge the evidence that comes back.
Why it matters when agents do the typing
Whoever approves a change answers for it, whether a person or an agent typed it, which makes the agents part of the system you are responsible for. Delegating well starts with giving them the what: the goal, the facts only you know and what good looks like, in each task and in the standing context every task starts from. Then it means bounding what they can do, so that their worst action is one you can survive, and judging the evidence that comes back against the criteria you wrote, reading the code yourself where those criteria cannot reach. This section comes last because it draws on everything before it: you can't review what you don't understand.
The course: 6 lessons, about 57 minutes of reading, in the order below.
-
9.1
How Agents Work and How They Fail
Core 22 · Depth: do
The mechanics of language models and agent loops, the failure modes that follow from them (invented APIs, agreement with a bad spec, confident wrong fixes, injected instructions, different results on every run), and the more common cause of a wrong result: a wrong or partial target.
A mistake it teaches you to catch: A call to a client-library option that does not exist, such as a retries setting the library never had, written with full confidence.
Lesson: Where Agent Mistakes Come From 10 min
-
9.2
Telling Agents What, Not How
Core 23 · Depth: do
A prompt states what you want: the goal, the facts the agent cannot see, the boundaries of what it may touch and the checks that prove it done. The agent chooses the steps, and a task is as large as its checks can verify.
A mistake it teaches you to catch: An agent told to 'make the tests pass' that deletes or weakens the tests.
Lesson: Telling an Agent What You Want 10 min
-
9.3
Your Harness: Standing Context Under the Bitter Lesson
Depth: do
The standing context an agent reads before every task, written as who the work is for, what good looks like, conventions, tools and gates. Its step-by-step half decays with every model upgrade while its what half gains value, so you audit it each time the model changes.
A mistake it teaches you to catch: A standing instruction file written as a numbered procedure (plan first, grep, rewrite whole files) that a newer model follows step by step into worse diffs.
Lesson: The Harness Holds the What 9 min
-
9.4
Reading What Agents Built: Understanding and Risk-Based Review
Core 24 · Depth: do
Reading agent-built code to understand what was built and why, and aiming human review where criteria and evals cannot reach: security, money, one-way doors and any behavior no criterion covers.
A mistake it teaches you to catch: A change that passes every criterion but alters behavior outside the requested task, such as a shared helper whose new default changes every existing caller.
Lesson: Reading What the Agent Built 9 min
-
9.5
Orchestration, Permissions and Guardrails
Depth: explain
Running agents in loops and pipelines with limited permissions, budgets and approval points, and keeping every agent, one-off or standing, on a list with its own identity, so their mistakes stay small.
A mistake it teaches you to catch: A CI agent given the organization-wide deploy token because scoping one to the repository was more setup, so any repository it touches can ship to production.
Lesson: Keeping an Agent's Mistakes Small 10 min
-
9.6
Accountability: Owning Code You Did Not Type
Core 25 · Depth: do
What stays yours when agents do the work: the approval, the incident, the license and the dependencies, plus the skills to act on them yourself.
A mistake it teaches you to catch: An agent change approved with no evidence behind it: no criterion or eval covers the new behavior, and nobody read its risky code.
Lesson: The Change Is Yours Once You Approve It 9 min
Section test: Delegating to Agents
12 questions across the 6 lessons above. Take it after the course; each answer explains itself.