Processes Over Prompts

I build AI tools for a living, so I field a constant stream of "can AI do this?" The answer is almost always yes, and that's the trap. Because it can, people now reach for a prompt where they once would have written a rule. Sorting leads into categories. Choosing which email goes out. Flagging which submissions need follow-up. Tasks with a known, correct answer, the kind that could have been automated twenty years ago.

The prompt feels like the shortcut, but it doesn't skip the work. The rules still get written; they just end up inside the prompt, in English, where the job shifts from executing them to convincing a model to follow them. And that trade is worse than it looks. A rule built into the system executes for free, instantly, the same way every time. A model interpreting that same rule costs money on every execution and is occasionally, quietly, wrong: right often enough that nothing looks broken, wrong often enough that leads misroute and submissions fall through, with no way to reproduce the error on demand. Industry AI failure rates, RAND puts them above 80 percent, roughly twice that of ordinary IT projects, get blamed on immature technology. A meaningful share is simpler than that: the wrong tasks were selected in the first place.

None of this is an argument against AI. It's an argument about placement.

Every automation decision reduces to one distinction: does this step have a correct answer, or does it require judgment?

A rule has a correct answer you could write down today. "If the lead mentions nursing or RN, route to the healthcare team." Nothing to figure out, nothing to interpret: it needs execution, not intelligence.

Judgment has no single correct answer. "Write a headline that makes someone keep reading." Ten competent people produce ten different good headlines. No one can hand you the rule, because there isn't one.

Rules belong in traditional automation. Judgment is where AI earns its place. Most business processes are overwhelmingly made of rules, with a small number of judgment-shaped steps scattered through them, and it's exactly those steps that used to make the whole process impossible to automate.

Before putting AI on any process, draw the whole thing as a flowchart. Then ask the real question:

Most of them can. Wherever boxes and arrows reach the correct answer every time, the rule already exists. Automate those the old way. It will be cheaper, faster, and it will never quietly get it wrong.

The clearest warning sign, and I see it constantly, is instructions written for the AI that are a flowchart in paragraph form. "If the response mentions X, categorize as Y. If it mentions A, categorize as B. Otherwise, C." That's finished logic, written in English instead of built into the system, now being re-guessed on every execution. If your team knows the rule well enough to explain it to the AI, they know it well enough to not need the AI.

This is the same failure I've written about from the model's side: an LLM call is a typed function, not a place to dump logic your system could have executed deterministically. A prompt that re-derives a fixed rule every call is a function with no business being non-deterministic. It's the same lesson a weather app teaches: if the logic can be expressed as a conditional, express it as a conditional, and the best LLM call is often the one you don't make.

What's left, the boxes you genuinely can't fill, is where things get interesting.

For decades, plenty of processes couldn't be fully automated for one reason: somewhere in the middle sat a step that rules couldn't handle. Free-text input. Inconsistent phrasing. A judgment call. The rules could cover ninety percent of the flow, but that one messy step meant a person had to sit in the loop, and once a person is in the loop, you're paying human speed and human cost for the whole process.

That gap is AI's actual job. A small, tightly scoped call, classify this free-text answer into one of six known categories, extract these three fields from this messy paragraph, turns unstructured input into something rules can process. Then deterministic automation takes over and does what it has always done: run instantly, for free, correctly, every time.

In my world, that looks like a prospect typing a free-text answer about their career goals into a form. No rule can parse "I've always wanted to help people, maybe something medical?" But a scoped AI call can map it to a program category, one constrained decision, from a fixed list of answers. Everything downstream of that decision is rules: routing, scoring, delivery to the CRM. The AI touches one step. The process went from human-dependent to fully automated.

The third column automates more than rules alone ever could, at a fraction of the cost and risk of handing the whole flow to a model. That's the actual promise of AI in operations: not replacing your automation, extending its reach.

The businesses getting real returns from AI aren't the ones using it most aggressively. They're automation-first: a deterministic core doing the heavy lifting, with AI placed deliberately at the seams where rules run out. AI's contribution to their operations isn't intelligence, it's reach. Processes that were 90 percent automatable and therefore 0 percent automated are now fully automated, because one small model call bridged the gap.

That reframes the job of leadership. The scarce skill right now isn't spotting places to add AI, the answer to "where can we use it?" is everywhere, and it leads straight back to prompts over processes. The skill is saying no: refusing AI a seat in every box that already has an answer, and funding it only for the ones that don't. Draw the process. Find the boxes that can't be filled. Put AI there and nowhere else. You'll automate more than the AI-everything approach, and you'll trust the result.

It's the same discipline behind choosing a regular project with one smart function over an AI project: the win comes from how little of the system the model actually needs to touch.

The most valuable AI in your business isn't the model running everything. It's one model call surrounded by a thousand if-statements.