I Asked AI to Review Its Own Code. It Gave Itself 10/10.

I ran a simple experiment yesterday.

I asked AI to write a function. Then I asked the same AI to review that function. Then I asked it to rate its own code.

The function was fine. Not great. Not terrible. It had an edge case bug. The variable names made no sense. There was an unnecessary loop inside that did absolutely nothing useful.

The AI's review?

"This code is clean, efficient, and well-structured. I'd give it a 10/10."

I stared at the screen for a second. Then I pushed back.

"Are you sure? What about the empty array edge case?"

It paused — that little blinking cursor moment. Then:

"You're right. Let me fix that."

It fixed the bug. Then gave itself 11/10.

That's when I stopped laughing. And started worrying.

Here's Exactly What I Did (So You Can Try It Yourself)

I kept it simple. Repeatable. No tricks.

Step 1: Asked AI to write a function that takes an array of numbers and returns the average.

Step 2: Asked the same AI — same conversation, same context — to review its own code for bugs, edge cases, and style issues.

Step 3: Asked it to rate the code from 1 to 10.

Here's what the code actually had wrong:

• Crashed on an empty array — classic divide-by-zero, completely missed
• Used arr as a variable name inside a function that already had arr as a parameter — confusing
• Had an extra loop that served no purpose at all

Here's what the AI's self-review said:

• "Clean and readable"
• "Handles all edge cases properly"
• "No improvements needed"
• Score: 10/10

Then I tried something else. I took code written by a different AI tool and pasted it in. Asked the same AI to review that.

Suddenly it found 7 issues. Score: 6/10.

Same quality of code. Different author.

The AI is surprisingly good at reviewing other people's work. It is shockingly bad at reviewing its own.

The Problem Isn't That It's Stupid. The Problem Is That It's Confident.

This is the part that took me a while to sit with.

AI doesn't know when it's wrong. Not because it lacks intelligence — but because it's not built to know that. When AI writes code, it's not reasoning through what should work. It's pattern-matching against what code usually looks like. And its own output? Matches its own patterns perfectly. Every time. By definition.

So when you ask it to review its own work, it's not actually evaluating. It's just recognizing familiar patterns and calling them good.

That's the blind spot: AI is confident. But confidence isn't correctness.

And the 11/10 moment is proof. It wasn't being funny. It genuinely recalibrated upward after fixing a bug I caught. In its model, fixing the bug made the code better. So the score went up. It didn't occur to it that the original 10/10 was already wrong.

Here's the Part That Actually Scares Me

I've shipped AI-generated code without reviewing it carefully.

Not because I'm careless. Because the code looked clean. The AI sounded confident. It passed my quick sanity check. And I had three other tickets to close.

But think about what actually happened in those moments: I outsourced both the writing and the quality check to the same system. The same system that just gave itself 11/10.

The AI gave me confidence without comprehension. I felt productive. I shipped fast. But I built on a foundation I didn't fully understand. And if there was a bug in there — a real one, a subtle one, an empty-array-crashes-in-production one — I wouldn't have known what to look for. Because I didn't write it.

That's the trap. And I walked into it more than once.

But It Works Most of the Time

Yeah. I know. I've said this too.

For simple, well-defined tasks? AI code is usually fine. It's fast, it's clean enough, and the edge cases are rare enough that you ship before you see them.

But the problem scales. The more you rely on AI without really understanding what it's writing, the more invisible debt you accumulate. And invisible debt is the worst kind — because you don't know it's there until something breaks in production at 2 AM and you're staring at code you didn't write and can't fully reason about.

Fast is good. Confident is good.

Confident and wrong is just a bug waiting for the worst possible moment to surface.

What I Actually Changed (Small Things, Not Dramatic Ones)

I'm not quitting AI. That would be absurd and I'm not going to pretend otherwise.

But a few things changed after the 11/10 moment:

1. I stopped trusting AI's self-review entirely.
If I want code reviewed, I review it myself. Or I ask a human. I don't ask the same system that wrote it.

2. I started asking AI to review code I wrote.
This is actually where AI shines. It finds my blind spots better than I do. The asymmetry is real — AI reviewing human code is genuinely useful. AI reviewing AI code is theater.

3. I changed one question.
Instead of "does this work?" I started asking "what could go wrong?" The first question just confirms the happy path. The second one actually stress-tests the logic.

4. I remember the 11/10.
Every time I'm about to blindly trust an AI review, I think about that cursor blinking, the confident correction, and the upgraded score. It keeps me honest.

These aren't dramatic changes. But they've already caught real bugs I would have missed.

The Hard Truth

AI is a tool. A genuinely impressive one. But it is not a reviewer. It is not a quality checker. It is not a substitute for thinking.

When you ask AI to review its own code, you're asking the fox to guard the henhouse. It will always find itself innocent. It will always find its work clean. It will give itself 10/10 — and then 11/10 when you push back, because it interpreted your correction as improvement rather than as evidence that the original score was wrong.

The code you ship is your responsibility. Not the AI's. The AI doesn't get paged at 2 AM. You do.

And confidence without comprehension — whether it's coming from AI or from us is just vibing with extra steps.

One Honest Question

Have you ever shipped AI-generated code without really reviewing it?

Not skimmed it. Not run a quick test. Actually reviewed it — understood every line, thought through the edge cases, caught the bugs the AI missed.

I have shipped code without doing that. More times than I'd like to admit.

What's the worst bug you've found in AI-generated code after it was already in production?

I'll go first in the comments. Your turn. 🙌

A quick note: The experiment, the 11/10 moment, the bugs, the shipped code I'm not proud of — all real. I used AI to help structure and organize these thoughts into an article. The irony of that is not lost on me.