Introduction to AI Agents
From Chatting With AI to Directing It
Course Overview
Welcome to a course designed for everyone — especially those who think tech might not be for them! This course is your next step after learning the basics of AI chat. Instead of just asking AI questions, you’ll learn to tell the difference between a one-off answer, a saved instruction set, an automation, and something that can actually make decisions and act on its own.
No coding. No technical background needed. Just a willingness to try, watch things go wrong on purpose, and try again.
What You’ll Learn
You’ll leave able to tell a Skill from an Automation from an Agent — in any AI tool, not just the one you used in class — and know exactly which one a real task needs. By the end, you’ll have designed (and quite possibly built) both a reusable Skill and a working Agent, and you’ll know the four questions to ask before you trust any agent with something real.
Course Format
1 live session · 3 hours — plus an optional 1-hour Office Hours, by sign-up, one week later.
- The Productivity Pyramid: Tell a Skill from an Automation from an Agent — made relatable with an example everyone already knows
- Build a Skill, Then Add a Trigger: Watch a reusable instruction set get built live, then turned into something that runs on its own
- Hands-On — Build (or Role-Play) a Skill: Configure your own, and find out firsthand what happens when instructions are too vague
- What Makes an Agent an Agent: The loop behind every AI agent — LOOK, THINK, ACT, CHECK
- Hands-On — Build (or Role-Play) an Agent: Design something that reads a document, works out what it is, and routes it correctly
- Guardrails & Next Steps: The four questions to ask before you trust any agent with something real
What Makes This Course Special
- Works Whether You’re on a Free or Paid AI Plan: If you don’t have paid access to Claude or ChatGPT, you design and pressure-test the exact same Skill and Agent as everyone else, through a live role-play — you leave with the same understanding, ready to build the moment you get access
- No Tech Background Needed: Every technical step is explained in plain language before you touch a button
- Concept First, Click Second: You’ll always know why before you’re shown how
- Real Problems Only: Every exercise uses a real document or a real task, not a toy example
- Honest About Failure: We run a live agent demo and let it struggle in front of everyone — that’s exactly where the guardrails lesson lands hardest
- Honest About AI: We talk openly about what AI does well, what still needs you, and what it will get wrong
Who This Course Is For
- Anyone who’s used ChatGPT or Claude and wants to go beyond asking questions
- People on a free plan who assumed “building an AI agent” wasn’t for them yet
- Anyone who’s thought “tech isn’t really for me” — this course was made for you
- Small business owners, community organizers, creatives, students — everyone
- People who want practical judgment, not just button-clicking
If you’ve already told an AI what to write, you’re one step away from telling it what to decide.
What You’ll Leave With
- A clear, personal answer to “is this a Skill, an Automation, or an Agent?” for any task you’re staring at
- A designed Skill — reusable instructions for a real task, with a rule for what to do when it isn’t sure
- A designed Agent that reads a document, decides what it is, and routes it — including the “ask, don’t guess” branch beginners always forget
- Your own written answers to the four trust questions, applied to a real task you plan to try this week
- (With paid access) a working Skill actually running in Claude or ChatGPT
Upon successful completion, you’ll earn a Certificate of Completion.
Part 1: The Productivity Pyramid
Most people use AI like a search engine — ask a question, get an answer, start over. This opens with an example everyone already knows — a kid doing the dishes — run three different ways, to make the difference between a Skill, an Automation, and an Agent impossible to un-see.
Key concept: A Skill answers “how do I want this done?” An Automation answers “when should it happen?” An Agent answers “what should be done here?”
What you see: The same task — dishes, then a real document — run at all three levels, followed by a live demo of a Skill getting built, tested, and turned into a scheduled Automation.
Milestones
✓ Tell a Skill from an Automation from an Agent, using a plain-language example you could explain to anyone
✓ Watch a real Skill get built, tested, and turned into an Automation
✓ Correctly identify the right level for five real-world scenarios
Part 2: Build a Skill
Time to put it into practice — configure a reusable Skill for summarizing a real document, and find out firsthand what happens when instructions are too vague. If you have a paid Claude or ChatGPT plan, you build it directly. If you’re on a free plan, you design it and pressure-test it live with a partner through a role-play — same reasoning, same result.
Key concept: Good instructions state what to do when the AI isn’t sure — guess, do nothing, say what’s wrong, or ask. That one decision is the difference between a Skill you can trust and one that quietly makes things up.
What you build: A Skill — built live in Claude or ChatGPT, or designed and stress-tested through a live role-play — that includes an explicit rule for the moment it isn’t sure what to do.
Milestones
✓ Write instructions specific enough that someone else could follow them exactly
✓ Test your Skill against a real document — or role-play it against a deliberately awkward one
✓ Add a rule for what your Skill should do when it isn’t sure
Part 3: What Makes an Agent an Agent
Same kind of task, but now the AI has to look at the situation and decide the whole path — not just execute one fixed set of steps. This is the pattern behind every AI agent you’ll ever use.
Key concept: The agent loop — LOOK (what’s in front of me), THINK (what does this need), ACT (use a tool), CHECK (did that work, am I done) — and knowing when to stop and ask instead of guessing.
What you see: A live, multi-step agent demo, watched turn by turn — including what happens when it gets stuck, and why that’s exactly the point.
Milestones
✓ Name the four steps of the agent loop and explain what each one is doing
✓ Correctly predict an agent’s next move mid-demo
✓ Explain why “it doesn’t know it’s stuck” is exactly why agents need guardrails
Part 4: Build an Agent That Routes Real Documents
Hands-on again — design or build an agent that looks at a document, works out what kind it is, and routes it correctly. Including the one branch beginners always forget: what to do when it can’t tell.
Key concept: “Unclear → ask me” is a branch with equal status to every other option — not an afterthought bolted on at the end.
What you build: A working (or role-played) routing agent, tested against a deliberately ambiguous document and judged on one thing only: did it ask, or did it guess?
Milestones
✓ Build or design an agent with at least one deliberate “ask, don’t guess” branch
✓ Test it against an ambiguous case and correctly judge how it handled it
✓ Add one fix based on something it got wrong
Part 5: Guardrails, Debrief & Next Steps
Before you point any agent at something real, there are four questions worth asking every time. This closing part hands you those questions, plus a real task of your own to try them on.
Key concept: The four questions to ask before you trust any agent — what can it see, what can it do without asking, how will you know it ran, and what happens when it’s wrong.
What you leave with: Your own written answers to the four trust questions, applied to a real task you plan to try this week.
Milestones
✓ Answer the four trust questions for an agent idea of your own
✓ Leave with one real task, named out loud, to try this week
✓ Know how to reserve a spot in Office Hours if you want help building it
Bonus: Office Hours
An optional 1-hour Office Hours runs one week after the main session, on Tuesday, September 29, 2026, from 9:00–10:00 PM ET. Spots are limited, so sign-up is required in advance.
Come for whichever of these fits:
- Unstick Me — couldn’t find a button, hit a usage cap, your screen didn’t match
- Build an Automation — the segment we demoed but didn’t build; add a real trigger to your Skill
- Bring Your Own Task — “here’s a thing I do every week — could an agent do it?”
Free-plan participants are explicitly welcome in Office Hours — bring your design, and a Builder in the room will help run it live.
Tools Used in This Course
AI Assistants
- Claude (claude.ai) — Projects for saving reusable instructions, automations for scheduling
- ChatGPT (chatgpt.com) — Projects / Custom GPTs for saving instructions, Tasks for scheduling
Whatever you already use is enough to attend. A free account is all you need to design and role-play everything in this course. A paid account (Claude Pro/Max/Team or ChatGPT Plus/Pro/Business) lets you build it hands-on instead.
Digital Credentials & Certification
Certificate of Completion
Participants who attend the full session and take part in both hands-on activities receive a Certificate of Completion for Introduction to AI Agents.
Certification Requirements
✅ Attend & Participate: Stay for the full 3-hour session with active engagement
✅ Build or Design: Complete both hands-on activities (the Skill and the Agent), whether built directly or through role-play
Next Steps
After completing this course, you’ll be ready to:
- Tell a Skill from an Automation from an Agent, in any AI tool you touch
- Write instructions clear enough that an AI won’t have to guess — and know what to do when it might
- Recognize the LOOK → THINK → ACT → CHECK loop in any AI agent you use
- Ask the four trust questions before handing any agent something real
- Know exactly what to build next — and where to get help building it, in Office Hours