How to build your first AI process that actually works

An AI process is a process with a clearly defined input and output, a single task for the model, validation outside the model, and a final measurement performed on real data.

The previous piece ended with the outline of a solution: pick one process, describe it carefully, build a verification, measure the result. I got plenty of replies in the same spirit: "all right, but what do I actually do once I sit down to it?"

A fair and pointed question. The difficulty of AI transformation lies in the tedious, often exhausting work you have to do between "I picked a process" and "the process runs without me watching it." No magic happens here, and nothing materializes on its own.

So let's assume you already have your one process: it repeats at least once a week, you can document it step by step, and it has a clear success criterion. You can judge whether it works and measure how well. That's already a lot.

AI transformation in practice isn't a tool rollout; it's rebuilding one process in six steps. Let's look at them through a concrete example: preparing a working draft of a response to an incoming request for quote. Repeatable, measurable (the quote goes to the client without major edits, or it doesn't), easy to document. Your process will certainly look different, but the steps stay much the same.

Step 1: break the process into its smallest parts

Open a note, take a deep breath, and write down how the process really looks today. Don't describe the ideal world, and don't reach for the manual or documentation nobody has updated in years.

Back to the example. Someone reads the email with the request and works out what the client actually wants; then prepares a quote based on the price list and other factors, and checks availability. After that they write the response; someone else reviews and approves it, and the quote goes out into the world. Your first task: next to each step, note how long it really takes (in minutes). Almost always, one step turns out to eat most of the time. Well done, now you know what to focus on.

Step 2: define the inputs and outputs before you use the model

We're often impatient, and the presence of AI gives us a sense of racing to the finish. And it's easy to make the mistake where the model gets something slightly different each time, so it answers differently each time. That isn't AI being unpredictable; it's a lack of consistent input data. The same applies to the output: if the model has no imposed response structure, we can get something that looks different every time.

A note here: before you drop anything into the model, decide exactly what you're giving it and in what form. In the example above we have the text of the request, the price-list extract for the given category, and one sentence about availability. Always those three elements, keeping the same order. We'll write a similar structure for the model's expected response, but more on that shortly.

Step 3: build the smallest possible AI step

If you want real results, "write the quote" won't cut it. Give the model a concrete, single task whose result you can check in isolation from the rest of the process. For example: based on the email request and the price list, produce only a table of line items with prices. Skip the intro, the closing, and the extra pleasantries.

Based on the request and price-list extract below, return a table: item | quantity | unit price | total. If an item isn't in the price list or you can't find it, write "not in price list" instead of guessing.

Notice the second sentence of the prompt. You don't leave it to the model to decide whether to admit it doesn't know (or that it couldn't get access to the data, which is also a common reason). This approach isn't tied to any particular model either. Use whatever you prefer: it'll work in Claude, ChatGPT, Grok, and so on.

Step 4: add a stage independent of the model

If the result of the previous step went straight to the client, that would mean real business risk in practice. What you send is, by definition, understood as checked and approved by you, so it directly affects your company's reputation. That's not a risk worth taking blind.

In practice, every sensibly and safely built pipeline needs at least one step that isn't a language model: a rule, a script, or a person with a checklist.

Our example is simple, and a script is enough here: one that checks whether every line in the table has a price and whether "not in price list" appeared anywhere. If discrepancies show up, it rejects the output before anyone sees it. We won't avoid hallucinations, at least not yet, but we can live with them knowingly.

Step 5: verify on real data

A demo of solutions like this is usually encouraging and inspiring. Except that in business, what counts is repeatability and predictability. That's exactly why the key next stage is feeding real data into our loop. Drop the last thirty real requests into the system. If you're short on data, ask a few people to send an email of this kind, but don't give them any instructions (in the real world, after all, clients don't use the same template to write their emails).

Now run those requests through the process and count: how many quotes went out with no edits, how many with a minor correction, and how many were fit for nothing at all. Here's where the key measurable result appears: concrete numbers. It might turn out that "68% of quotes go out unedited". It's a fact that older models often got lost in the nuances. Though the latest ones do far better, it's still only your validation from step 4 that will confirm whether everything is in order.

Step 6: decide and scale: fix or drop

At this stage you already have a measurable result, so you have every basis to decide what comes next. The whole process now looks like this:

Input → AI step → validation → measurement → decision

If the result is satisfying and you can still improve it a little with small prompt tweaks, there's a basis to start thinking about scaling. Here, of course, you have to account for the human factor: the team needs time to get used to the new process and to feel for themselves that it works. Ambiguous results can still point to the source of the problem. Sometimes it's enough to fix just one of the process steps. The next measurement will tell you the truth about whether it was worth it. But if the result, despite every attempt, still isn't satisfying, then it's time to stop flogging a dead horse and say it plainly: this process clearly isn't a good candidate for optimization with AI. That, too, is very valuable knowledge. It's certainly not the kind of experience worth gaining after you've already rolled the solution out in the business and picked up worried feedback from clients.

That's all of it, and it's a lot. Really.

Whatever the scale, the entire AI transformation is that one loop, repeated for the next processes. A process broken into "atomic" stages, with a clear input, an unambiguous step, evaluation outside the model, and measurement on real data.

Sounds tedious? Well, Rome wasn't built in a day. But it's the only way you'll get automation that genuinely works over the long run.

You can walk this loop yourself, following the instructions above. There are no traps, no catches, no fine print. But if you'd rather not learn it through your own experiments, and you'd like someone who has been through it dozens of times to do it with you, then that's exactly how we work. Or just get in touch and let's start with the most time-consuming step, the one that gives us a foundation for everything else.