The skeptical agent: why one AI is never enough

There's a common misconception when people talk about "AI agents." The thinking goes that if you just find a smarter model or one with a longer context window, you'll build a system that finishes a task without you having to hold its hand.

I've spent quite a bit of time building these workflows lately—moving from simple prompts to complex systems for research and coding. I've learned something in the past year or so that I think will help everyone trying to use AI to help them with their tasks: AI is fundamentally blind to its own mistakes.

If you want something done right, you can't just trust the first agent that does the work. You need to hire a second one to try and break it.

The problem with the single loop

When I'm "vibe coding" — directing an AI through conversation — ideas that sound simple become more complex as I explore them. Maybe it's Python code to scrape a site for job opportunities or a research brief on a niche topic.

The first agent is incredibly good at being helpful. It wants to give me exactly what I asked for, but that helpfulness is also its biggest weakness. Because the model is just predicting the next most likely token based on your instructions, it stays locked into its own logic.

If the first agent makes a mistake in step two (like hallucinating a library method or missing context from a document) it will carry that error through the rest of the task with total confidence. It isn't "thinking"; it's just following its own tracks, even if those tracks lead off a cliff.

It can't see the gap because it is the gap.

The necessity of the skeptic

The breakthrough for me was realizing a while back that the useful move in agentic workflows isn't making one AI smarter — it's orchestration.

I stopped trying to write "the perfect agent" and started building a skeptical pass.

In my current workflow, if I'm using an agent to collect info or draft code, the last step is a hand-off. I move the output from Agent A (The Doer) over to Agent B (The Skeptic).

Agent B doesn't do the task again. Its only job is to find where Agent A lied, missed something, or hallucinated. I give it a specific persona, like a critical editor or a senior developer looking for edge cases.

After constantly asking the AI to create a skeptical subagent to review the work, I created a skill that invokes the agent and gets on with its job. The description is something like "Spawn a skeptical sub-agent to hostilely review code just written or changed, hunting for bugs, security holes, and false assumptions before declaring it done."

How it changes your work

Instead of hoping for the best, you can actively act like a conductor that knows the job has several stages, and the skeptical agent is the last one.

1. The error rate drops. Instead of catching half the AI's hallucinations by hand, you catch many more because the second agent is specifically looking for them.
2. Your mental energy shifts. You aren't staring at code wondering "is this right?" You are looking at a report from your Skeptical Agent that says: "I found two issues." It's easier to debug a specific critique than it is to audit an entire block of work from scratch.
3. You build processes, not prompts. You stop obsessing over how to phrase a single instruction and start thinking about the steps required to verify the output.

The bottom line

If you are building something with AI — whether it's a script for research or a tool for documentation — assume the first result is wrong. Use another agent to verify the work because the value here is that it inspects the work without assumptions. This simple change to your workflow will improve the quality of your output immensely.