You don't need a strong model to build

Every month someone asks me which AI they should buy. Claude or ChatGPT, this tier or that one, should we wait for the next version. I said it in the first issue of my newsletter and it has only firmed up since: which model you pick is close to the least important decision you will make.

Here is what I see instead, across every build I have run this year. The businesses getting real value are not using better models than everyone else. They are using the same models, wired differently.

Two words, in plain English

A model is the engine. You type something in, it answers once, and it stops. It does not remember your business, it cannot open your inbox, and it has no idea whether its answer was right. Every AI you have heard of is one of these, and you rent them all by the month.

Agentic just means the engine got put into a machine. Instead of answering once and stopping, the system works the way a careful employee works: it breaks the job into steps, does a draft, checks the draft against your standard, fixes what failed, pulls what it needs from your actual systems, and only then brings you the result to sign.

That checking loop is the whole difference. It is also why the model stopped mattering so much. There is a well-known experiment from early 2024 in which an older, cheaper model wrapped in that kind of loop beat the newest model used the ordinary way, by nearly thirty points. I see the same thing on the ground constantly. The loop decides the quality. The model just has to be good enough, and they are all good enough now.

What a loop looks like in a real business

Not a tech demo. Three shapes I have built or scoped this year.

A health practice that publishes content. The clinician records one conversation. The system transcribes it, drafts a month of posts, and, because this is a regulated field, the compliance rules run before anything is written rather than being checked after. Every piece still lands in front of a person who signs it. One recording in, a month of publishable work out, nothing published unsigned.

A business that quotes for work. Every quote gets scored against the firm's own criteria before it leaves the office: margin rules, scope traps, the things the owner always catches on a good day. The system catches them on every day. Under-priced or off-standard quotes stop going out, and the owner stopped being the bottleneck on quote day.

A services firm handling enquiries. An enquiry arrives. The system reads it, looks up what the firm knows about that kind of client, drafts a qualification note and a first-pass proposal against the written playbook, and a second check runs the pricing rules. The owner reads, adjusts, signs, sends. What used to take an evening takes the time it takes to read it.

Three different industries, one identical shape: the system does the work, the rules run first, a named person signs everything that leaves. If you read issue two of my newsletter, this is the harness with a motor in it. The harness holds what the AI must know and never do. The loop is that harness actually running your work, on its own, up to the signature.

The catch, and it is the same catch as always

A loop can only check work against a standard that is written down.

Most businesses do not have one. The standard for a good quote or a good proposal lives in the owner's reactions to drafts. That works, at the cost of the owner reading every draft forever. The system cannot check against a feeling, and neither can your newest employee, which is why this problem predates AI and why fixing it pays twice.

So most of the real work of going agentic is not technical. It is writing down what you already know: what a good one looks like, what must never go out, who signs. If you can write the checklist you give a careful new hire, you have written the loop's standard.

Where to start, and where not to

Start with the human approving every single item before it leaves. Let the system earn a lighter touch with evidence: after months of clean output, maybe you check a sample instead of every item. Client-facing and regulated work can stay at every-item forever, and that is fine. The loop still does the drafting, the checking and the chasing. You keep the judgment and the signature.

Pick one workflow with three properties: it happens at least weekly, you could describe good output on one page, and a mistake caught at your desk costs little. Enquiries and quotes fit most service businesses. Anything that moves money or makes public promises on its own does not, and should not for a long time.

The ninety-minute version

Take one workflow you would love off your plate. Write down the steps as they actually run, including the workaround everyone uses. At each step ask two questions: could a system do this if the rule were written down, and is the rule written down anywhere?

Every step where the answers are yes and no is your real project, and it costs nothing but an afternoon to fix. Then the loop is mostly assembly.

The models will keep improving whether you do this or not. The loop will not build itself. That half is yours, and it is the half that decides whether you own the result.

Reply and tell me which workflow you would point a loop at. I read everything, and the answers shape what I build next.