The course, section by section

Six sections, thirty-six lessons. One recurring job, carried the whole way through: you brief an agent, give it tools, check its work, bound what it can reach, and turn its mistakes into rules it keeps.

▶ Watch the 9-minute introduction

What the course is about

Learn to build AI agents that are briefed, scoped, checked, bounded, and improving with every run.

The agent itself stays probabilistic. What you build around it is a harness of deterministic parts — checks that pass or fail, limits that fire or do not. Everything is taught in plain English and demonstrated in Claude Code: you direct, you do not program.

The worked example is a monthly run of financial documents, simplified for teaching. The documents are only the example — the method is for anyone with a job that repeats and has to come out right.

The five questions the course is built on

Section 1 sets up the shift from chatting to directing. Sections 2 to 6 each answer one question about the agent you are directing.

1. What is it working with? — Context

Your knowledge, kept current, with a method for what loads and what is fetched.

2. What can it touch? — Tools

Reach is the outer bound of impact: what it can touch, not what you asked, sets the worst case.

3. How is it checked? — Verification

Stop accepting ‘done’; a check defined before the answer exists, run outside the agent’s say-so, settles the routine case.

4. What’s it not allowed near? — Guardrails

Build limits in, not request them; prefer the reversible; route the irreversible through a person.

5. How does it learn? — Self-improvement

Propose a rule from a real failure; keep it only after review and a retest.

Section 1

Understand the Difference Between Chat and an Agent

By the end of this section you will understand what an AI agent is, how it differs from a chat assistant, and what you need in place to direct one successfully, and you will know the six operating assumptions of agentic AI, conservative defaults this course plans around, chosen so a framework that assumes them stays safe even when a product does better, that make a framework necessary.

Lessons

  • The Difference Between Agentic AI and Chat AI
  • What an AI Agent Knows and What It Must Be Told
  • The Problems with Agentic AI: Overconfidence
  • The Difference Between Controlling and Directing an AI Agent
  • Building a Reliable Framework Around the Agent
  • Giving the Agent Clear, Unequivocal Instructions

Section 2

Build the Agent’s Knowledge Base (Context)

Answers: What is it working with?

By the end of this section you will know what to put in front of an agent and what to leave out, so it works from what is true about your job rather than filling the gaps itself.

Lessons

  • The Knowledge an Agent Lacks at the Start of Every Job
  • The Difference Between Standing Knowledge and the Brief
  • Giving the Agent a Memory That Persists Between Jobs
  • Why Separating Each Kind of Knowledge Produces Better Answers
  • Reading Back What the Agent Drew On and Why
  • Assembling the Agent’s Working Knowledge and Brief

Section 3

Give the Agent the Tools It Needs

Answers: What can it touch?

By the end of this section you will understand what granting a tool actually means: a door to something real that stays open for as long as the grant lasts, and how long that is depends on the product, per call, per session, or standing until revoked.

Lessons

  • The Difference Between an Agent That Talks and One That Acts
  • Why Reach, Not Instruction, Sets the Worst Case
  • Delegating an Agent Its First Real Task
  • The Danger Surface an Agent’s Reach Creates
  • Granting Only the Access the Job Needs
  • Defining the Agent’s Scope of Access

Section 4

Verify the Agent’s Work Independently

Answers: How is it checked?

By the end of this section you will understand the difference between a claim and evidence, and a typical progression of evidence strength, not a universal ranking, since strength finally rests on independence and coverage: the agent’s account, the artifacts it produces, deterministic checks over those artifacts, reconciliation against a source the agent did not produce, and a person’s review for what stays high-risk.

Lessons

  • Why ‘Done’ Is a Claim and Not Proof
  • Defining ‘Done’ as an Observable Test in Advance
  • Compelling the Agent to Show Its Work, Not Assert It
  • Reading a Failed Check as a Signal of Where It Went Wrong
  • The Difference Between a Real Check and a Reassuring One
  • Defining the Success Test for a Recurring Job

Section 5

Define the Agent’s Boundaries and Safety Net

Answers: What’s it not allowed near?

By the end of this section you will understand why an instruction is not a limit. You will know how to build firm limits into the agent’s work, keep a tested way back for everything that can be undone, and put a person’s approval in front of the few actions that cannot.

Lessons

  • The Difference Between a Sign on the Door and a Lock
  • Building the Limit In Rather Than Asking for It
  • Reversibility: Engineering a Way Back
  • Why a Guardrail Can Fail and How to Catch It
  • Locking the Irreversible Action, Not Merely Watching It
  • Designing the Agent’s Limits and Recovery Together

Section 6

Turn Mistakes Into Standing Rules

Answers: How does it learn?

By the end of this section you will understand why you cannot assume a correction survives the session. You will know how to turn a verified failure into a reviewed standing rule the agent keeps, retested so a new rule cannot quietly break what worked, so the tool improves run over run.

Lessons

  • Why the Same Mistake Twice Is the Real Failure
  • The Correction Loop: Converting Failure Into a Standing Guideline
  • Writing a Real Failure Into the Agent’s Standing Knowledge
  • Improving by Subtraction, Not Accumulation
  • The Disposable Output and the Lasting Asset
  • The Completed Directed Tool, Owned and Trusted
Scroll to Top