I Let Two AIs Double-Check Each Other. They Started Apologizing—and Made Me Afraid of My Old Code

When AIs Start Apologizing to Each Other

Lately, I have been using multiple AI sessions to double-check my development work more often.

I have set up a workflow in which one session implements something and another reviews it. If the reviewer raises a question, the sessions exchange their findings directly: the original session rechecks the implementation, responds to the reviewer, and revises the work when necessary. I do not manually relay messages between them.

In other words, I use cross-session review.

This occasionally produces a strangely entertaining scene: the AIs start apologizing to each other with remarkable politeness.

“You’re right. My understanding was incorrect.”

“After checking again, I found that my criticism was also mistaken. I apologize.”

Then, as if nothing happened, they begin producing a corrected version.

You two certainly get along well.

I could probably make them argue more aggressively, but I am not interested in watching AIs fight. As long as the mistake gets fixed, I am satisfied.

Watching these peaceful exchanges, however, made me realize something else.

They had been making this many mistakes all along.

What I Could Not See with a Single Session

With cross-session review, one AI routinely finds problems in the design or code produced by the other.

“This requirement has been interpreted incorrectly.”

“This case has been overlooked.”

“That API is not being used correctly.”

The original AI checks the criticism and responds, “You’re right.”

Of course, the reverse also happens. Sometimes the reviewing AI is mistaken, and the implementing AI pushes back. After another look at the code or requirements, the reviewer apologizes: “I misunderstood.”

It is not so different from a human code review.

The problem is that I used to do all of this in a single session.

A Single Session Carries Its Mistaken Assumptions Forward

We have always known that AI makes mistakes. Cross-session review has simply made the scale of those mistakes much more visible to me.

When all the work happens in one session, an early misunderstanding of the requirements can become the foundation for everything that follows.

What makes this especially dangerous is how convincing the result can be. The AI gives reasons, produces plausible-looking code, and offers even more detailed explanations when questioned.

The explanation becomes increasingly impressive even though the underlying assumption is wrong.

Unless the human notices that something feels off, the mistake can pass unnoticed.

When the workflow sends the same code and requirements to a separate session, however, that session sees them from a different context. That is when you hear, “No, that is not right.”

The criticism is then routed back to the original session automatically, and it responds, “Yes, that is correct.”

An AI that sounded completely confident on its own suddenly begins admitting mistakes as soon as a colleague arrives. There is something oddly fascinating about that.

Then My Old Code Started to Frighten Me

That led me to a deeply unpleasant question: what about the code I developed back when I relied mainly on a single session?

I did conduct reviews and run tests at the time. But I did not pit independent AI sessions against each other nearly as often as I do now.

When an AI said, “The implementation is complete. All tests have passed,” there were times when I simply accepted that the work was done.

Now, after that same declaration, the workflow automatically brings in another AI session.

It often begins with, “There is one issue with this implementation.”

The issue then goes back to the original AI automatically. It checks the criticism and says, “You’re right.”

Wait a minute. You just told me it was finished.

After this happens a few times, it becomes difficult not to question older work as well. I plan to conduct a thorough new review of the parts I built mainly with single-session workflows.

If the review finds nothing, that will be good news.

It will probably find something.

Adding a Second AI Made Me Afraid of the First

This is not an argument against using AI. Quite the opposite.

If AI makes mistakes, we can use AI to help check those mistakes.

Just as a person can reread their own writing many times and still miss the same typo, asking one AI session to “review your own implementation again” may leave its original assumptions unchallenged.

So I let an automated workflow send the work to a separate session. If the two disagree, it has each one examine the other’s reasoning. I only step in for the final judgment.

Cross-session review did not teach me that AI had become more intelligent. It reminded me of a much simpler truth: never place too much trust in a single AI.

Mistakes that remained invisible when one AI worked alone began appearing one after another as soon as I brought in a second.

Cross-session review has not increased my trust in AI. If anything, using two AIs has made me afraid of the days when I used only one.

Even today, on my screen, the AIs are politely bowing to each other:

“My understanding was incorrect. I apologize.”

“No, I also failed to check carefully enough.”

It is all very peaceful, which is nice.

The real question is what they were getting wrong back when there was nobody else for them to apologize to.