Lesson 1 - The Checker Matters More Than the Prompt

Welcome to The Checker Matters More Than the Prompt#

This is the first lesson of the module the whole course points at, so let’s open with its most important and most counterintuitive claim: the quality of a loop comes from the check, not the prompt. Almost everyone believes the opposite. When an AI gives us something wrong, our instinct is to rewrite the request — a better prompt, a cleverer instruction, a magic phrase. This lesson argues that instinct is misplaced, and that the effort you’d spend perfecting prompts pays off far more when spent on the check.

By the end of this lesson, you will be able to:

• Explain why the check, not the prompt, decides a loop’s quality
• Describe the “leverage” difference between the prompt and the check
• Recognize the instinct to fix the prompt when the check is the real problem
• See why this module is the heart of the whole course

Let’s start with the instinct almost everyone has.

The Instinct to Blame the Prompt#

You ask for something, the result is off, and you immediately think: I must have asked wrong. So you rewrite the prompt — more detail, a different phrasing, an example or two — and try again. Sometimes it helps. But notice what this instinct assumes: that the fix is always in how you ask. That’s prompt engineering, and it’s genuinely useful. It’s also, on its own, a trap, because a better prompt still produces just one attempt — and you still have no reliable way to know whether that attempt is actually good.

Here’s the uncomfortable part. A more polished prompt often produces a more confident-looking result, which is exactly the thing that fools you. It reads better, so you trust it more, so you check it less. The prompt improved your confidence without necessarily improving the truth. If there’s no real check between the attempt and you, a great prompt just means you get lied to more persuasively.

Where Quality Is Actually Decided#

Think back to the loop from Module 1: attempt, check, correct, repeat, stop. The prompt influences the attempt — one moment in the loop. The check is different: every single attempt, every round, passes through it. It’s the gate that decides whether the loop corrects again or stops. That structural fact is the whole argument.

Put two loops side by side. In the first, you have a brilliant prompt and a weak check. The attempt is good, but the check can’t tell good from bad, so it rubber-stamps whatever comes out — including the round where the AI quietly invented a fact. In the second, you have a rough prompt and a strong check. The first attempt is mediocre, but the check catches exactly what’s wrong, the correction fixes it, and a few rounds later the result is solid. The loop with the strong check wins, even though its prompt was worse. That’s leverage: the check is the part that decides the outcome of every round, so it’s the part worth engineering.

The Check Is the Part You Actually Control#

There’s a second reason to invest in the check. You don’t really control what a language model generates — you nudge it, but the same prompt can produce different attempts, some good and some not. What you control far more tightly is the check: the criteria you compare against, how strictly you apply them, whether you demand evidence. And you can make the check as reliable as you’re willing to — a hard rule like a word count is deterministic, giving the same verdict every time, which is exactly why the next lesson pushes you toward rule-based checks wherever a task allows.

One honest caveat, though, because it matters for the rest of the module: not every check is deterministic. When the check is itself run by an AI — a rubric it scores, an “is this accurate?” judgment — the check is also probabilistic and can be wrong or biased, for the same reasons any AI output can. So an AI-graded check is a real, useful check, but not an infallible one. The practical rule: lean hardest on the parts you can pin to a firm rule, treat AI-judged checks as helpful-but-fallible, and the more a result matters, the more you anchor the check to something outside the model’s own opinion (the techniques of the next few lessons). The check is the part you can make most reliable — not a part that’s automatically reliable.

This is also why the strongest checks are the concrete ones. A check like “does this read well?” is barely a check at all — it’s a vibe. A check like “is it under 250 words, does it name Saturday’s event, are all the mentioned books in our stock list?” gives you clear yes/no gates the loop can’t smooth-talk its way past. The more your check rests on concrete, verifiable conditions, the less it depends on the model’s mood or your own tiring judgment. You’ll build exactly these kinds of checks across this module.

It’s worth being honest that a good check takes more effort to write than a good prompt — you have to think about what “done” really means and how you’d confirm it. That upfront cost is precisely why people skip it and reach for another prompt tweak instead: prompting feels like progress, checking feels like work. But the effort isn’t wasted, it’s relocated to where it pays off. A prompt tweak helps one attempt and is gone; a well-built check keeps catching problems on every future run of the task. You’re not doing more work overall — you’re doing it in the place with leverage instead of the place without.

A Harborlight Example#

The owner wants a factual “our story” paragraph for the website. Two approaches:

All effort on the prompt. They spend twenty minutes crafting an elaborate prompt with tone guidelines and three examples. The AI returns a beautiful paragraph. It says the shop opened in 2011. It actually opened in 2009. The paragraph is so well-written that the owner doesn’t think to check the date — the polish bought trust, and the trust skipped the check. The error ships.

Modest prompt, real check. They write a plain prompt, but before accepting anything they check the draft against three concrete facts: founding year 2009, family-run, two weekly events. The first draft gets the year wrong; the check catches it instantly (“says 2011, should be 2009”); the correction fixes it; done. The prompt was nothing special. The check is what made the result trustworthy.

Same task, same model. The difference between a shipped error and a correct result was entirely in whether there was a real check — not in the artistry of the prompt.

Practice Exercises#

Exercise 1: Prompt fix or check fix?#

An AI keeps producing customer emails that sound great but occasionally promise refunds you haven’t approved. Is your first move to improve the prompt or to build a check? Why?

Exercise 2: Rate the check#

Which is the stronger check for a factual bio, and why: (a) “does this read professionally?” or (b) “are the job title, start year, and company name exactly correct against the source?”

Exercise 3: Spot the false confidence#

Describe a time a very fluent AI answer made you less likely to double-check it. What would a concrete check have caught?

Summary#

The central, counterintuitive claim of this module is that a loop’s quality comes from the check, not the prompt. The instinct to fix a bad result by rewriting the prompt is a trap, because a better prompt still produces only one attempt — and a more polished attempt often just fools you into checking less. The check has the leverage: the prompt touches a single attempt, while the check evaluates every attempt in the loop and decides whether to correct or stop. It’s also the part you actually control — the reliable gate in an unreliable process — and it’s strongest when it rests on concrete, verifiable conditions rather than vibes like “reads well.” A rough prompt with a strong check beats a brilliant prompt with a weak one, every time. That’s why the scarce, valuable skill is building good checks, and why this module is the heart of the course.

Key Concepts#

• Leverage — the prompt shapes one attempt; the check governs all of them, so the check matters more.
• Confidence trap — a polished attempt lowers your guard, so a great prompt can mean being fooled more persuasively.
• The controllable part — you nudge the model but fully control the check, making it the reliable half of the loop.
• Concrete check — one built on verifiable yes/no conditions, not a subjective “reads well.”

Why This Matters#

Most people’s frustration with AI, and most of the errors that slip through, come from over-investing in how they ask and under-investing in how they check. Flipping that ratio is the single highest-return change you can make in how you work with these tools — it’s what turns “impressive but untrustworthy” into “dependable.” Everything else in this module builds on this one idea: since the check is where quality lives, it’s worth learning to build checks that genuinely work. Next, you’ll meet the main kinds of checks — from quick checklists to hard tests — and learn which one fits which job.

Continue Building Your Skills#

You’ve met the idea the rest of the course leans on: the check, not the prompt, is where a loop’s quality is decided, because it’s the one part that judges every attempt. Carry the healthy suspicion of a fluent answer — polish is not proof. Next, you’ll build a toolkit of check types, so that whatever you’re looping on, you know what kind of check will actually catch its problems.