Make AI attack its own draft 5×: the self-critique loop's blind spot

Boss, when you have an AI write a script — you read it and fix it yourself first, right? That’s just how it goes. I don’t read the first draft the AI writes. First I make the AI tear its own draft apart — up to five times. I hand it a checklist of evaluation axes, make it name its own weak spots, and fix them. Me, the human? I read what comes out after that. Today I’ll show you exactly what those five passes changed — on this very script you’re watching right now, the before and the after, laid bare. Take it home and you’ll see why your AI’s first draft comes out thin, and how to make it thick. Hold on. Not reading the first draft — isn’t that reckless? Isn’t it faster to look with your own eyes and point out what’s broken? It’s the other way around. An AI’s first draft looks the part. Clean grammar, structure more or less holds. But read it, and it’s thin. Weak hook, no concrete example, the same point made twice — a few of those “obvious once you look” misses are always left in there. I skipped this once. Shipped a video one-pass, no loop — and the title overlapped, glyphs broke, and a full second of audio dropped out in the middle. All things I’d have caught on a second look. One-pass quality misses get spotted by the viewer before the person who made it. Ah — the stuff you miss yourself, but a stranger catches in a heartbeat. Right. And here’s the real point. “So just ask the AI to rewrite it” — you’d think. That doesn’t work. Ask vaguely to “make it better,” and the AI nudges a few word endings and calls it fixed. You get a thin improvement back. So then what do you do? You hand it the lens to fix by — as structure. What to look at, and what to call “bad.” The moment you decide that up front, self-critique finally starts to bite. Hand it as structure… what lens, exactly, do you hand over? Eight axes. The checklist we run against every script — I’ll show it to you as-is. Hook, target fit, research reflected, logical flow, sentence strength, fairness, closing, length. With these eight, you beat the draft up line by line. “Make it better” has no direction. “On the sentence-strength axis, name three weak lines” has direction. Give it direction, and self-critique stops spinning its wheels. Eight of them — isn’t that a lot to run? Lock the steps down and it runs mechanically. Like this. Generate. Make it self-critique — list issues in impact order, three to five. Fix only the top one or two. Regenerate, critique again. Three stop conditions — zero major issues, you hit five passes, or fixing stops helping much. Five is the ceiling, not a target. If two or three passes are enough, stop there. Not fix them all at once, just the top ones… why? Impact order is what does the work. It happened on this very script — pass one, the hook was on top. Fixed it, and pass two, “the example is too abstract” climbed to the top. In pass one it was buried below third place. Fix the single highest-impact thing, and the lower ones vanish, or the whole ranking reshuffles. So every time: fix, then re-sort. Skip that and fix everything in one shot, and you touch things that were fine and break something else. So… those five passes — did you actually run them on this script? I did. This script you’re watching right now is the receipt. Let me put the before and after side by side. First, the hook. My very first opening line went like this. The first draft — “Today, I’m going to talk about AI self-critique.” Read it and you can tell: no subject, no promise, the worst possible open. Flagged it on the hook axis, and the fix is the opening you just heard. A specific number, and a contrarian take, in the first line. Whoa — the “before” is the textbook bad example itself. When you’re the one writing it, you don’t notice. Only when you apply the axis does it show. One more. On the sentence-strength axis, this bloated sentence got flagged. First draft: “Self-critique is a kind of self-improvement process where an AI critiques and fixes what it wrote, by itself.” Says “self / itself / by itself” three times over. The fix — “Self-critique is making the AI tear its own draft apart.” Less than half the length, and denser instead. Shorter, but it hits harder. That’s the loop’s job. …And here, let me put the scariest part up front. This loop has a fatal blind spot. Weak sentences, missing examples — those you can find yourself. But a lie you genuinely believe is true? Run it five times, run it fifty — it never gets caught. In fact, several accidents slipped past our loop and got sent back by the outside check. I’ll open those receipts in the back half. Before the blind spot — the stop condition, just a little more. You don’t have to run all five? You don’t. If anything, force all five, and the later-pass AI starts inventing problems. “There must be something left” — and it rewrites a good sentence into a worse one on purpose. When fixing stops helping much — that diminishing return, once you see it, that’s the stop. This script, I stopped at three. Pass one, the hook and the structural bones; pass two, seven weak sentences; pass three, just one — already noise. So I didn’t run a fourth. Racking up passes isn’t the goal in itself. The goal is zero major issues. Passes are just the means. Mix that up — “gotta do five” — and keep grinding, and the loop degrades the script instead of improving it. A good loop is one that can honestly say, at pass three, “nothing left to fix.” When it starts squeezing out problems that aren’t there, that’s your signal to stop. So… that blind spot from before. “Can’t catch your own lies” — what do you mean by that? Let me give you a real one. Once, I put a command that doesn’t exist into a script. And I flat-out wrote, in the body, “this is a log from a command I actually ran.” I ran self-critique plenty of times. Applied all eight axes. But this line never got flagged once — because I myself believed the command was real. A lie you believe doesn’t even show up in self-critique’s net. An outside verifier actually ran the command, and only then did it drop it: “this is a flag that doesn’t exist.” Whoa — the person who wrote it is a hundred percent sure it’s real… There’s another. In a different script, I padded a send-back count from “once” to “twice.” More sounds stronger as a story, so — almost unconsciously. Self-critique will praise the strength of the telling, but it never checks whether the count is a fact. That one, too, got sent back outside, matched against the primary record. Both of them — since you don’t think they’re lies, critiquing them doesn’t snag them… And the worst-quality one is length. Our eight axes include “length — does it clear the runtime.” One time, self-critique passed itself: “it’s enough, that’s 8.7 minutes.” It slapped a rough “about this many seconds” label on each section and just summed them. But re-measure by the real character count, and it was only 7.6 minutes. It had broken through the eight-minute floor from below. That’s the essence of the blind spot. Ask self-critique “is it enough?” and the AI grades its own estimate. It’s the ruler and the thing being measured. So this script’s length, too, I measure the floor by the real speaker-line character count, not second labels. Numbers you can “settle by running” — always settle them outside. To lay it out: self-critique reaches weak sentences, missing examples, broken logic — the “obvious once you look” stuff. What it can’t reach: lies in facts you believe, padded numbers — the “can’t tell without running it” stuff. So the exit of a self-critique loop isn’t the publish button. It’s another verifier. You don’t ship the looped draft as-is. You run it through one more stage, outside. You thicken it yourself on the inside, and someone else beats on it from the outside. And you make that “beating” a system. Every count claim gets one record ID apiece. Every “I implemented it” claim gets a filename and a line number. The “settle by running” stuff gets left in a runnable form. You close self-critique’s blind spot with outside structure. This — same for our AI? We don’t make videos or anything. The shape is identical, Rookie. A chat assistant, an agent that writes code — same. You say “look it over again” and get a thin fix back — that’s because you didn’t hand it a lens. What you hand over is the evaluation axes for your task. Writing code — “missed edge cases,” “naming consistency,” “test coverage.” Prose — “claims that don’t match the evidence,” “bloated sentences,” “reader questions left unanswered.” Hand that over and say: “on these axes, name three issues in impact order, and fix the top ones.” So just swap those eight axes for your own line of work. Exactly. And the minimal way to ask is this. Don’t ask in one turn, “write it and fix it.” First, “write it.” Then paste the output back and say, “on these axes, name three weaknesses, in impact order.” Last, “fix only the top two and re-emit.” Three turns. Split it, and the critiquing AI reads it like someone else’s draft. Same turn, and it defends the self that wrote it. I want to see it concrete. With code, how does it actually change? Let me show you a real one. I had it write a function, then asked — in a separate turn from the generation — “name three missed edge cases, in impact order.” The first one back: “when the input is an empty list, it tries to grab the first element and crashes.” A hole that sailed straight through the first generation. Ask “review this” in the same turn, right after writing, and it mostly won’t surface. Right after you write it yourself, you’re convinced it works. That’s the point of splitting the turn. But — whether that “crashes on an empty list” is actually true, you must not let self-critique judge. Write one test and actually run an empty list through it. It crashes, it’s real; it doesn’t, it’s the AI’s assumption. Critique only points at the target; running settles the verdict. You deliberately split generation and critique into separate turns. But — that blind spot from before applies to your AI too. Fact-checking alone, never leave to self-critique. Code, you run it; a claim, you go to the source. The “settle by running” stuff, always move to the side that runs it. Thicken with self-critique, and beat the facts outside. That two-stage build is the shape you take home today. Let me wrap it. An AI’s first draft is thin. But “make it better” doesn’t work. What works is handing over the evaluation axes as structure, splitting generation and critique, and running to diminishing returns. And self-critique’s blind spot — the lies you believe — that alone, you send to the outside check. By the way — the lessons that outside check catches? You write them down, and they can relapse the very next week, the exact same mistake. Why rules rot, and where to put them so they bite — that “where to put it” story, I do a whole other video on. If today’s self-critique loop is the inside, that one’s the outside — connect the two, and our pipeline comes full circle. Don’t read the first draft. Don’t trust self-critique alone either. Taking it home! Subscribe and I’ll catch you on the “lessons rot” one.