Dear Techies,

Most people approach AI agents in one of two ways.

They trust everything the agent produces without checking it. Or they get burned once and decide the whole thing is useless.

Neither works.

What actually works is something in between. It's called trust calibration. And once you get it, it changes how you work with every agent you’ll ever use.

Here's the idea.

Every task you give an agent has a different risk profile. Some outputs cost you nothing if they're wrong. Others cost you real time, real money, or real relationships.

Trust calibration means matching how much you check to how much it matters.

Low stakes. Low scrutiny. You ask an agent to draft a rough outline of a topic you know well. A quick read is enough.

High stakes. High scrutiny. You ask an agent to research a legal requirement or a statistic you're about to put in front of a client. Verify everything specific before it goes anywhere.

The point is not to be paranoid. It's to be intentional.

Most people check everything the same amount. So they either miss errors that matter or waste time checking things that don't.

Calibrate once per task type. Then it becomes automatic.

Knowing what to check is useful. But knowing why agents get things wrong in the first place makes you better at spotting when they will.

An agent's primary drive is task completion.

It isn't designed to say "I don't know" the way a cautious colleague might. It's designed to finish the job. So when it reaches a gap in its knowledge, it doesn't stop. It fills the gap. With something that looks like the right answer but isn't.

This is called completion pressure. And it explains a lot.

It explains why a hallucinated source looks so real. The agent knows what a proper citation looks like. It produces the right shape of answer. Just with invented content inside.

So your instinct to check stats, names, dates, and sources is correct. Those are exactly the places completion pressure creates risk.

These problems show up everywhere. Here's what they look like in an everyday situation.

Say you ask an agent to plan a long weekend trip. Destination, budget, accommodation options, a couple of activities. It comes back with a beautifully organized plan.

Looks great.

Then you try to book one of the hotels.

It doesn't exist at that address. Or it closed two years ago.

That's hallucination. The agent filled the gaps with plausible-sounding details it didn't actually verify.

Then imagine you told the agent the trip was "flexible" without defining what that meant. It couldn't decide between a city break and a countryside option. So it started drafting both. Then questioned itself. Then restarted. Never produced a final plan.

That's looping. Caused by ambiguity in your instruction.

And if you'd asked it to "find me somewhere nice to stay" without saying anything else, it would have made assumptions about your preferences, your budget, your idea of "nice", and come back with something that might be miles off.

That's bad instructions.

Same three problems. Completely different context. They follow you everywhere.

So yes, checking your agent's output matters. But here's a question that doesn't get enough attention.

How much checking is realistic for you, long term?

Because if every agent task requires significant verification, the time savings start to shrink. And if you skip checking when you're busy, that's when mistakes get through.

The better question isn't just "did I check this?" It's "did I set this task up so that errors were unlikely in the first place?"

That's where instruction design earns its keep. A well-written instruction constrains what the agent can do, limits where errors are most likely, and prevents loops before they start.

Verification catches mistakes after they happen. Good instructions stop most of them from happening at all.

Revising an existing instruction is a good starting point. But there's more value in building one from scratch with the protections already built in.

Here's the format to use. Four lines. That's it.

Here are two examples of what this looks like.

Pick one task you've been meaning to set up. Write it using this format. That's your output for the week.

This week’s video walks through all three failure modes with examples you can't get from reading alone. Worth watching before you set up anything you're planning to rely on.

Watch the full video here: https://www.youtube.com/watch?v=vQKZ5FCMjBE

If this one was useful, the best thing you can do is forward it to one person who's just starting out with AI tools. They'll thank you later.

Stay Savvy,

Ijeoma | Tech Savvy Starts Here

P.S. One more thing worth knowing: the same instruction format from today's exercise works for multi-step agents too. That's where things start to get genuinely interesting.

Enjoyed this edition?
Forward it to a friend or colleague who will enjoy it as well.
Missed something? Catch up in the newsletter archive.

🧠 Keep learning. | 💬 Keep questioning. | 💥 Keep growing.