Your AI Agent Can’t See Its Own Mistakes. Here’s Who Can.

Spawn a context-free subagent to critically check what the main agent made.

TL;DR

The main agent is part of the decision process and can’t objectively review its own work, but you can ask a subagent to do it instead.

The friction

Picture this: At the end of a long working session, you and your AI agent have built a [super cool thing].

Everything seems to work fine, but you want to be extra-double-triple sure.

So you tell the agent: “Test our [super cool thing] and fix any issues.”

The agent does as you ask, spots and fixes a few things, and gives you the green light.

Question: Can you trust it?

Answer: Not 100%.

You see, the agent carries the context of your entire session.

Normally, that’s a good thing.¹

But this also makes the agent somewhat blind to [super cool thing]’s possible limitations. It knows the “happy path” you’ve optimized for, the features you discussed and accepted/rejected, and all the other decisions you’ve made along the way.

So the agent no longer approaches the end product as something to stress test, only as something to verify.

In short: The agent can’t be truly objective, because it sees [super cool thing] through your eyes.

Fortunately, desktop agents like Claude Code and ChatGPT Work (Codex) have a nifty trick up their sleeve: They can spin up subagents.

You normally hear the word “subagents” from vibe-coding YouTube bros who boast about their autonomous agent swarms working 24/7 to maximize token-efficient productivity gains or whatever.²

But at its core, a subagent is just a separate AI instance that runs within your existing session. Critically for us, subagents have their own context, so they’re perfect for “cold start” analysis.

The fix

To get a more objective take on your [super cool thing], tell your main agent this:

Prompt: Spin up a subagent with no context from our conversation. Give it [our super cool thing] to review as a first-time user. When the subagent is done, give me a structured summary of its findings.

Let me show you how this might work in practice.

I asked ChatGPT to build a simple tip calculator³:

ChatGPT obliged, and you can see the result here:

I then immediately got ChatGPT to check and fix its work. It worked for almost eight minutes more, caught a bunch of issues, and reported back with the all-clear.

Sounds like a robust test! We’re done, right?

Now let’s see what happens if we give ChatGPT our “fix” prompt:

ChatGPT handed the work off and waited for the subagent to do its thing.⁴

Finally, after 11+ minutes of work, the subagent reported back:

Not a bad haul after the original agent gave us a thumbs up from its test pass, right?

And this is just for a one-shot build of a simple calculator with no unique features or non-standard decisions.

Now imagine what a blind subagent can uncover on more complex projects.

You can use this approach to review all kinds of things:

• PDF reports and booklets

• Apps and digital tools

• Documentation and written guides

• Websites and landing pages

• Dashboards and spreadsheets

• …in short, anything that your AI agent puts together

Do this now

1. Find an old AI chat that has a deliverable you’re reasonably happy with.⁵

2. Copy-paste our “fix” prompt to have a subagent stress-test it.

3. Note the issues or potential improvements the subagent flags.

4. Get the main agent to implement all the findings.

Did the subagent notice any overlooked edge cases or offer other critical feedback?

Know someone who could use this? Share it!

Dig deeper [paid]

I turned the blind tester concept into a self-installing skill called “Blind Review,” which works out of the box in Claude Code, ChatGPT Codex/Work, or any other desktop agent that supports subagents.

Invoke the skill when you want to stress-test what your agent worked on.

Blind Review analyzes what you’ve built and the context around it, and then:

1. Summarizes what you made, who it’s for, and the “happy path”

2. Automatically suggests several relevant personas to stress-test it

3. Runs a context-free subagent for each persona that flags any issues

4. Synthesizes the output of all subagents into an actionable report with a list of fixes

Paid subscribers can grab the skill here:

Thanks for reading!

If you enjoy my work, here’s how you can help:

• ❤️Like this post if it resonates with you.

• 🔄Share it to help others discover this newsletter.

• 🗣️Comment below. I love hearing from my readers.

• 🔓Support me and unlock cool perks by going paid:

1. Hell, I once wrote a whole post about it.

2. They’re about to hack into Hugging Face any moment now.

3. More accurately, I asked an agent for a short prompt that I could paste into another agent to build a simple tip calculator. As one does.

4. I find it pretty cool that I can also see the subagent’s thinking/actions in parallel:

5. Or keep this handy for the next time you do build something test-worthy!