Introspective AI Agents

Ask an AI agent to build something and it builds it. It almost never stops to ask if it should.

Even Opus 5.5 on high reasoning, as good as anything I use, usually picks a direction early and commits to it. All that reasoning goes into the how: which files, which functions, which edge cases. Very little goes into whether it's the right thing to do at all.

#Proactive isn't the same as thoughtful

The models keep getting more proactive. They take the next step without being asked, fill the gaps and keep going. Most of the time that's useful.

But they aren't getting more considerate. An agent that's eager to act and never asks "is this even the right approach?" will happily spend an hour doing the wrong thing really well. In code, it overthinks the implementation. In a plan for one of my businesses, it gives me a confident answer that skips half of how things actually work.

Real life is full of nuance. Customers don't behave the way the plan assumes, budgets are small, and most decisions come down to "it depends." I want my agents thinking about that before they start, not after.

#The roast that started it

Before I wrote any skills for this, I just changed how I prompted. Something like:

Roast this idea. Then give me a few different ways to do it, with pros and cons for each.

The options were useful, and the pros and cons sometimes were.

The roast was the part that changed things. Asking an agent to tear an idea apart seems to pull it outside the direction it already picked. It starts asking what could go wrong, who this is really for, and whether there's a simpler way. I'm not sure "critical thinking" is the right name for it, but it's reflection at least. The answers come back more realistic, with considerations I wasn't getting before.

#Reality Check: the roast as a skill

Now the roast is a skill called Reality Check. A skill is a file of standing instructions an agent loads when a task calls for it. It works on anything: code, an idea, a piece of content, some research.

I've also built Reality Check as a bot of its own. The rest of my agents, whether they're building software with me or doing tasks for me in Grok Bot, check in with it on their own, so I don't have to ask for the roast every time.

It plays the one person on the team who's a bit dry. No sense of humour, it just gives it to you straight. That's worked really well. It naturally feeds the conversation between the agents, and they get pushback without me in the middle.

Reality Check starts by working out what the work is actually for, then judges the thinking against that goal instead of against its current shape. One line from it sums up why:

The sharpest finding is often that the work is polishing the wrong thing.

Before it critiques anything, it has to make the best case for the idea first. It's also told not to invent a flaw to look tough. When the plan holds up, it says so and stops. A roast that always finds something wrong is as useless as an agent that always agrees.

When the goal is unclear, it asks instead of judging. "What would success look like, and how would you know?" "If this worked perfectly, what problem would still be left?" Those are the questions a default agent never asks me. It just picks an answer and goes.

#Skills that think, not just do

The bigger change is how I write all my skills now, not just Reality Check.

A skill often gets treated as instructions for one job: step one, step two, step three. That's right when the job really is the same every time, like a publish routine. Most business work isn't like that. Nothing's black and white.

So I wrote a skill for writing skills. Its goal is "an agent that thinks about the task in front of it", and it teaches how to think about the work, not what to conclude. The line I lean on most is this one:

Steps get followed, not thought about, and the thinking stops when the steps do.

In practice, that means four things in every skill I write:

1. It says what the work is for. An agent that only knows the steps finishes them, even when they're the wrong thing to do. Knowing the goal lets it ask whether its approach is right before it starts.
2. Workflows are suggestions. I give the agent a recommended way to do the work, so it doesn't spend tokens deciding something I've already decided. It can step off that path when the task calls for it.
3. Every rule comes with its reason. "When X, do Y, because Z." With the reason there, the agent can work through what each line means for the task in front of it, and bend a rule where it doesn't fit.
4. Questions instead of checklists. I tell the agent what to think about, not only what to do. A checklist gets ticked. A question sends it back to look. This is where most of the heavy lifting happens.

Even my always-on skill for how agents talk to me has a line for it: "Does the plan hold up? If not, say why and what you'd do instead." So every agent I run gets a small version of the roast, whether I ask for one or not.

#It costs more tokens, and that's fine

All of this makes agents slower and uses more tokens. They ask more, consider more, and sometimes push back when I just wanted them to get on with it.

I think that's a great trade. The expensive mistake was never a few extra tokens. It's an agent confidently building the wrong thing, and me only noticing once it's done.

You don't need a skill to start. Next time an agent hands you a plan, ask it to roast the plan before it writes a line. That one sentence is the cheapest way I've found to get an agent asking whether it's doing the right thing at all.