There is a moment almost everyone working with agents long enough eventually has.
You watch the agent finish something genuinely hard — a refactor, a long spec, a synthesis across a dozen sources. The output looks clean. You skim it, approve it, move on. And then, in a thought you would never say aloud: "Why am I even checking this anymore?"
That thought is the entry point to stage three.
01Four milestones on a non-linear road
Learning to work with agents is not like learning a conventional skill — where you accumulate knowledge on a straight upward slope and the peak is simply the most experienced you have ever been. With agents, there is a trap located precisely at the point where you think you have already cleared it.
Four stages — and almost no one passes through stage three without stumbling. This piece spends the most time there.
02Stage one — Prompt Tourist: bright-eyed and optimistic
You start. Your first prompt is something like: "Write me a function that handles a list of users."
The agent returns something that looks reasonable. You paste it in. It works. You feel the pull of something remarkable.
Then you try something harder. The output is close but not quite right. You ask it to revise; it revises in a direction you did not expect. You tighten the prompt; you get a different result. After five rounds of back-and-forth, you do it yourself.
Stage one is characterized by using the agent as a vending machine — put in a question, get back an answer, hope for the best. You have no mental model of why it gets things right or wrong, so you cannot predict it. You can only react.
The one thing that saves stage-one operators: you still verify. Because you do not yet trust.
03Stage two — Learning structure: seeing patterns, starting to design
At some point, you notice a few things:
- Vague prompts lead to wrong guesses, which cost more time to fix than doing it yourself
- Describing the expected output in advance dramatically improves the first try
- Some instructions you repeat every session — writing them once into a persistent context file means never explaining them again
You start using command structure. You add forcing functions: "Before writing any code, ask me if you are missing information." You build in gates — plan before starting, checkpoint mid-way. Results improve meaningfully.
This is where the real craft begins. You stop treating the agent as a magic machine and start treating it as a colleague who needs clear direction. You get better at giving that direction. And you still verify, because the habit from stage one is still there.
04Stage three — The trust trap: the most dangerous place
This stage happens gradually, with no clear moment of entry.
You have been working with agents for several months. You know how to prompt. Results have been good many times in a row. You feel like you have the rhythm down. You start reviewing outputs a little faster. Then a little faster still. One afternoon you are busy, you skim something and approve it without really reading it — and nothing breaks.
So the gap between "delegate" and "verify" keeps quietly narrowing.
The trap is subtle because, most of the time, the agent actually does good work. So the behavior gets reinforced. You approve fast → no problem → you approve faster → no problem → you barely verify → and then there is a problem.
The trap has no alarm. It happens in small decisions, one at a time, until the distance between what you trust and what you have verified is much wider than you remember it being.
The reason stage three is more dangerous than stage one: in stage one, you know you do not know. So you are careful. In stage three, you believe you do know. So you stop being careful.
The agent has not changed. It still gets eight things right and two things wrong, same as before. Only you have changed — you started reading the eight as evidence of ten, and treating the two as noise.
05Stage four — Calibrated: not less trust, but trust in the right places
People who exit stage three do not go back to stage two. They arrive somewhere different.
In stage four, you do not verify everything — that would be wasteful and unnecessary. But you also do not verify on instinct. You have a framework: is this task reversible? What are the consequences if it is wrong? Will someone else act on this output?
The answers to those questions determine how much attention you give to any particular result — not "the agent has been solid lately."
"If this is wrong, who finds out? When? How long to fix?" Answer those three questions before deciding whether to skim or read carefully.
Each time the agent does something meaningfully wrong, remember it. Not to distrust — but to have a real anchor when "it has been great lately" starts to feel like unconditional evidence.
Two habits for stage four. Not complicated — the hard part is keeping them consistent.
06You will not skip stage three
Almost no one jumps from stage two to stage four without going through the trust trap. Because knowing you are in stage three requires a fall hard enough to make you look at where you drifted.
The difference between people who exit stage three quickly and people who stay stuck is not intelligence. It is two things: a fall painful enough to change behavior, and a clear enough model to recognize where they are standing.
This piece is that model.
Stage three is where you stop verifying because you think you already know. Stage four is where you verify in the right places because you actually know — that the agent has not changed, only you have. And that your own change is exactly the thing most worth managing.