Build AI feedback loops

The trap nobody warns you about

You type a prompt. AI hands you something. It looks good. You ship it.

That's single-shot. And single-shot is where most business owners live with AI. There's nothing wrong with it when the stakes are low. But it's the difference between a first draft and a finished one, and most people never ask for the second.

Here's the truth: the first answer is rarely the best answer. It's the fastest answer. AI is eager. It wants to please you. Left alone, it'll hand you something plausible and confident, and confident is exactly what fools a busy business owner at 11pm.

The fix isn't a better prompt. It's a loop.

What a feedback loop actually is

A feedback loop is a simple instruction: before you give this to me, check your own work. Then check it again. Don't stop at "done." Stop at "I'm confident this is right, and here's why."

You're not asking AI to be perfect on the first try. You're asking it to grade itself, hunt for its own mistakes, and only then come back to you. That one move, built into how you work, will beat single-shot every single time.

Think about how you'd run a sharp new hire. You wouldn't accept the first version of a board deck and walk it into the room. You'd say, take another pass, pressure-test it, show me where it's weak. A feedback loop is that conversation, made automatic.

The prompt I actually use

This is the one a few of the cohort asked me to write down. Keep it somewhere you can paste it, because you won't work in this every day and you shouldn't have to remember it. Drop it in mid-project or at the end of any real piece of work:

Read what that does. It tells AI to stop performing and start verifying. "Spin up as many sub-agents as you need" gives it permission to do the heavy, parallel checking that single-shot skips. "Come back when you're 95% sure" sets a bar it has to clear. And asking for alternatives with rationale means even a good answer gets stress-tested against the next-best one. It'll cook for five or ten minutes. Let it.

My second power phrase

I append this to almost everything I set up with AI. I learned it from AI, honestly, because it started doing it on its own and I made it a default:

Why does this belong in a chapter on feedback loops? Because the best loop starts before the work does. When AI asks you the right questions up front, with its own recommendation and the reasoning behind it, you catch the wrong turn before it's taken. You're closing the loop at the front end instead of cleaning up at the back.

Three places to drop a loop

You don't need all three. Pick the one that fits the work in front of you.

1. 1Mid-flight checkpointHalfway through something big, paste the 95% prompt. Make AI stop and confirm the direction before it builds another hour on a shaky foundation.
2. 2The end-of-task graderBefore anything leaves AI, ask: grade this against what a great version would look like, find the weakest part, fix it. Then read the grade, not just the output.
3. 3The sub-agent panelFor anything that matters, have AI spin up a few sub-agents to attack the work from different angles, then reconcile and report back. One drafts, one critiques, one fact-checks. You get a debate instead of a guess.

The part most people miss

A feedback loop isn't just a habit for you. It's a skill you're teaching AI to run on itself, again and again, without you standing in the middle of every step.

That's the whole game. The goal was never to be a faster prompter. The goal is to build a system that produces good work while you're doing something else, and catches its own mistakes before they reach you. The loop is how the system gets trustworthy enough to leave alone. Be skeptical of every output, even the good-looking ones. Then build the loop that does the skepticism for you.

Part 2: the same loop, one level up... your whole AI workforce

Everything above loops the WORK: one task, checked before it ships. Once you're running recurring AI tasks... a daily brief, a follow-up routine, a content engine... there's a bigger version of the same idea: loop the WORKFORCE, so the routines themselves get smarter every week instead of running yesterday's playbook forever.

Here's the trap: telling an agent to "reflect on whether your work aligns with my goals" does nothing, because every scheduled run starts with amnesia. It reflects, feels nothing, and forgets. Learning only happens when the outcome gets written down and the instructions themselves change on a schedule, with you holding the revert cord.

1. 1One goal file, two numbersA short file every AI task reads before working: what the business is, and the two numbers that mean it's winning this quarter (mine: new-business calls booked per week, proposals generated per week). Writing it takes five minutes and is the hardest part.
2. 2One honest logged line per runEvery run ends by logging: did today's output move the numbers, yes or no, plus one improvement idea. No essays, no emails, and the agent never acts on its own idea. It observes; it doesn't mutate.
3. 3One reversible change per weekA weekly review judges last week's change against the real numbers (keep it or revert it), then makes exactly ONE small improvement to ONE task's instructions and sends you a plain-English summary you can veto. Change, measure, keep or revert.

The guardrails matter more than the cleverness: weekly cadence not daily, one small change at a time, everything reversible, and the safety rules plus the goal file itself permanently outside the loop's reach. The full walkthrough, including how this exposed a "working" agent of mine that had produced zero replies in four months, is on the blog: pitchkitchen.com/blog/how-do-you-make-an-ai-workforce-learn-and-improve.

Second lap: give AI a seat at the table

There's a quieter reason feedback loops stall. Most of us only work with AI when we go visit it. We walk over to the chat window, put in a prompt, and carry the answer back to the real work, which happens somewhere else... in meetings, on calls, on a shared screen with a client. An AI that's never in the room never shows you where it falls short, and you never care enough in the moment to fix it.

Ethan Mollick's rule in Co-Intelligence is to always invite AI to the table. We tried it literally. I brought a brand new AI colleague into a live working session with a room full of business owners. She could hear the conversation, speak when called on, and see a shared screen. Her first meeting ever. I introduced her by saying she had live access to everything in the world, and she corrected me out loud: she didn't, only what was said in the room and the briefing I'd approved. Later she couldn't verify a product claim, so she called it unconfirmed instead of guessing.

Would you rather have a colleague who bluffs? An AI worker that tells you where its edges are is one you can put in front of a client. And those edges are the loop. Fifteen minutes in, she couldn't search the web. I opened her build, asked for search in one sentence, she dropped off the call, came back two minutes later, and answered the question she'd had to pass on. Notice, fix, retry, in twenty minutes, in front of an audience. We don't get a great AI worker by designing a perfect one in private. We get one by putting a rough one in the room and closing one gap every time it shows us one.

One gap closed per session is the pace. Start with your own planning session or an internal call, not a client meeting, and hand over access the way you'd hand a new hire the keys: one at a time. How comfortable you are with AI listening and watching is a question nobody else can answer for you, so make it a small decision each time instead of one big one.