Talking to an Agent ≠ Talking to a Chatbot
The habits that make you good at chatbots actively hurt you with agents. This whole stage is about rewiring how you communicate with something that doesn't just talk back — it acts.
🎯 By the end you'll understand
Why working with an agent is delegation, not conversation; why the casual prompting style that works fine with a chatbot quietly sabotages an agent; and the four new priorities — front-load clarity, equip it, decide how far to trust it, and review what it did — that the rest of Stage 3 unpacks.
KEY INSIGHTThe one idea to take away
With a chatbot you have a conversation. With an agent you make a delegation. Those are different skills — and most people bring the wrong one.
You've spent years getting good at chatting with AI: toss a half-formed question, see what comes back, refine, repeat. It's fast, forgiving, and it works — because you steer every single turn. An agent removes that safety net. You set it up, then it runs many steps on its own before you see anything. The skill that matters shifts from steering to setting up well.
A chatbot is a back-and-forth where you're in the loop every turn. An agent is a hand-off where you're out of the loop while it works. Stage 3 is one long answer to the question: how do you hand something off well?
Welcome to the most practically valuable stage of the course. Stages 1 and 2 taught you what agents are and how they work under the hood. Stage 3 is the part you'll use every day: how to actually get good work out of one. None of it is technical. All of it is leverage.
CORE CONCEPTConversation vs delegation
Picture two ways you ask for help in real life.
The first is texting a friend: "hey what's a good restaurant near me?" You don't think hard about the message. It's vague on purpose — they'll ask "what kind of food?" and you'll answer, and you'll converge on something in a few quick rounds. The looseness is fine because the loop is tight. Every reply is a chance to course-correct.
The second is briefing a contractor you've hired to renovate your kitchen. You can't text "make it nice" and walk away for three weeks. They'll make a hundred decisions while you're not looking — cabinet height, tile, where the outlets go — and you won't see any of it until it's built. So you front-load: here's the budget, here's the style, here's what I can't live without, here's what to ask me about before deciding. You spend your effort before the work starts, because you won't be there during it.
A chatbot is the friend. An agent is the contractor. Same underlying intelligence (you learned that back in Lesson 1.1) — completely different relationship.
Delegation is handing a goal to something that will pursue it autonomously across many steps, with you supervising rather than driving. The quality of the outcome is decided mostly by how well you set it up — not by how cleverly you intervene mid-task, because you mostly can't.
WEAKNESSWhy chatbot habits break with agents
The single most ingrained chatbot habit is the tiny vague prompt. "Help me with my taxes." "Clean this up." "Make it better." With a chatbot, that's not laziness — it's efficient. The reply comes back in two seconds, and if it missed the mark you just say "no, I meant the German tax forms" and you're back on track. The vagueness costs you one extra turn. Cheap.
Now give that same vague prompt to an agent. It doesn't pause to ask. It commits. It interprets "help me with my taxes" however it happened to read it, then runs twenty steps down that interpretation — pulling documents, doing calculations, drafting forms — before it surfaces anything for you to see. If its first guess was wrong, you don't find out on turn two. You find out after it's already done a pile of confident, wrong work.
With a chatbot, a bad start costs one cheap turn. With an agent, a bad start costs twenty steps in the wrong direction — plus the time to notice, plus the cleanup. The earlier the mistake, the more compounding wreckage it causes.
This connects straight back to Lesson 2.9, where you saw how agents fail. A vague brief is the upstream cause of half of those failure modes. The agent didn't "go rogue" — it faithfully executed an under-specified goal. Garbage goal in, confident garbage out. The fix isn't a better model. The fix is a better brief.
SEE ITSame task, two mindsets
One task — "clean up this customer dataset" — handed over two ways. Flip the mindset and watch not just what you type, but what the agent then does with it. The difference is the whole lesson.
Same model, same task, same eight thousand rows. The only thing that changed is how much you said before letting go.
FRAMEWORKThe new priorities
If steering every turn no longer carries you, what does? Four things, in order. Each is a whole lesson coming up — this is the map.
📝 Front-load clarity
Say the goal, the context, the constraints, and what "done well" looks like — before it starts, because you can't add it mid-flight. This is the master skill. (Lesson 3.2 · The Art of the Brief)
🛠️ Give it the right tools & info
An agent can only act through the tools and data it's been handed. The right files, access, and capabilities matter as much as the words. (Lesson 3.3)
🎚️ Decide how much to trust it
How long a leash? Should it ask before risky steps, or run free? Autonomy is a dial you set per task, not a default. (Lesson 3.4)
🔍 Review what it DID, not what it SAID
The agent's summary is a claim, not proof. Check the actual output — the rows it changed, the code it wrote, the email it sent. (Lesson 3.6)
Notice the timing. Three of the four priorities happen before the agent runs, and the fourth happens after. Almost none of your effort goes during. That's the inversion: with a chatbot, the work is the back-and-forth; with an agent, the work is the setup and the review.
CORE CONCEPTYou're a manager now, not a chatter
Here's the reframe that makes everything click: stop thinking of yourself as a user typing prompts. Start thinking of yourself as a manager handing off work.
A good manager briefing a capable new contractor doesn't micromanage and doesn't abdicate. They do something specific: they make the goal unmistakable, supply the context the contractor couldn't know, name the constraints that aren't obvious, and define what success looks like so it can check its own work. Then they get out of the way — and inspect the result.
That's exactly the job with an agent. You're a director. The agent is talented but has no idea what you actually want unless you tell it — it can't read your mind, your inbox, or your unspoken standards. Every ambiguity you leave open is a decision you've silently delegated to a stranger who'll do something plausible and possibly wrong.
Before you hit run, ask: "If I handed this exact brief to a sharp new hire and then went on vacation for the duration, would they produce what I want — or would they have to guess?" Every guess you can eliminate now is a step it won't waste later.
This is also why the skill transfers. Get good at briefing agents and you get better at briefing people, because they're the same muscle: turning a fuzzy intention in your head into an unambiguous hand-off. Some of the most leveraged people in 2026 aren't better prompters. They're better delegators.
CONTEXTIt acts in the real world — so the cost is real
There's one more reason the brief matters more here than it ever did with a chatbot, and it's the reason all of Stage 3 exists. An agent acts. A chatbot that misunderstands you produces a wrong paragraph — annoying, but inert. You read it, shrug, and rephrase. Nothing happened.
An agent that misunderstands you produces wrong actions. It emails the wrong client. It deletes the rows it should have kept. It refunds the wrong order. It commits broken code. The mistake doesn't sit politely on screen waiting for your approval — it's already loose in the world by the time you read the summary. That's the through-line from Stage 2's failure modes: the danger of an agent isn't that it's dumb, it's that it's effective in a direction you didn't intend.
| Chatbot conversation 💬 | Agent delegation 🤖 | |
|---|---|---|
| Prompt size | tiny & casual — refine as you go | a full brief up front — goal, context, constraints, success |
| Who steers | you, every single turn | it does, across many steps, on its own |
| When you intervene | continuously — every reply | before (setup) & after (review); rarely during |
| What you review | the text it said | the work it actually did |
| Cost of vagueness | one extra turn — cheap | many wasted steps + real-world side effects — expensive |
That last row is the whole reason to read on. Vagueness was free with a chatbot. With an agent it has a price tag — sometimes a big one. Stage 3 is how you stop paying it.
WEAKNESSCommon mistakes to avoid
Chat reflexes — short, vague, fire-and-iterate — assume you'll steer the next turn. An agent doesn't give you the next turn until it's done a lot of work. Treating delegation like conversation is the #1 way people get bad agent results.
Later is too late. By the time you see the output, the wrong twenty steps already happened (and may have already acted on the world). Correction is cheap in a chat and expensive in a delegation. Spend the clarity up front.
You reviewed the explanation, not the work. The summary is the agent's claim about what it did — and a confidently wrong agent writes a confident summary. Open the actual file. (Lesson 3.6 is built around this.)
KEY INSIGHTWhere this connects in your course
- Chatbot vs agent (1.1) — the original "talks vs acts" split; this lesson is what that split does to how you communicate.
- The Art of the Brief (3.2) — priority #1, the master skill: goal, context, constraints, success criteria.
- Tools & info (3.3) — priority #2: an agent can only act through what you give it.
- How much to trust it (3.4) — priority #3: setting the autonomy dial per task.
- Review the work (3.6) — priority #4: checking what it did, not what it said.
This lesson is the doorway to Stage 3. Everything that follows is one of these four priorities, done in depth. Walk in thinking like a director, not a chatter, and the rest will feel obvious.
GLOSSARYKey terms introduced
- Delegation
- Handing a goal to an agent that pursues it across many steps on its own, with you supervising rather than driving each move.
- Brief
- The setup you give an agent before it starts: goal, context, constraints, and success criteria. The agent's output is largely decided here.
- Front-loading
- Putting your effort and clarity in before the agent runs, because you can't add it mid-task the way you can in a chat.
- Director mindset
- Approaching an agent as a manager briefing a capable contractor — make the goal unmistakable, then get out of the way and inspect the result.
- Intervention
- Stepping in to correct or redirect. Continuous with a chatbot (every turn); concentrated before and after with an agent.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1In one sentence, how is working with an agent different from chatting with a chatbot?›
A chatbot is a conversation where you steer every turn; an agent is a delegation where you set it up well, then it runs many steps on its own. The skill shifts from steering to setting up.
2Why is a tiny vague prompt fine for a chatbot but dangerous for an agent?›
With a chatbot, vagueness costs one cheap extra turn — you just clarify in the next reply. With an agent, a vague start means it commits to a wrong interpretation and runs many steps (often acting on the real world) before you ever see it. The cost of vagueness is asymmetric.
3What are the four new priorities, and when does each happen relative to the agent running?›
Before: (1) front-load clarity — goal, context, constraints, success criteria (3.2); (2) give it the right tools & info (3.3); (3) decide how much to trust it (3.4). After: (4) review what it did, not what it said (3.6). Almost no effort goes during.
4Why does the "manager briefing a contractor" analogy beat "user typing a prompt"?›
Because the contractor makes a hundred decisions while you're not watching, so you front-load the goal, context, constraints, and definition of done — then inspect the result. That's exactly the agent relationship: every ambiguity you leave open is a decision you've silently handed to it, and since it acts, a wrong guess has real-world cost.