Operations leaders are being asked a question this year that most of them did not ask for: where should we be using AI?
The question usually arrives from above, with an implied answer. It is a difficult question to engage with honestly, because the loudest available information comes from people selling something, and the quietest comes from teams who tried it and would rather not discuss the result.
The largest automation result we have delivered for a client involved no AI whatsoever, and choosing not to use AI is precisely why it worked.
The Case That Used No AI
Class Action Settlement House administers class-action settlements. Their bottleneck was claim filing: for every settlement, staff pulled each claim's details, typed each field into the settlement portal, and generated the agreement, one record at a time.
The time spent loading the cases is 80% to 85% of the time we are spending.
Lee, Class Action Settlement House
We automated it with headless-browser automation and deterministic scripting. Import a batch of claims and the system files each one to the portal, checks eligibility, fills roughly 90% of every form, and records the claim number that comes back. A human reviews the batch at the end.
The result was about 13,500 hours of manual processing eliminated and roughly $450,000 saved, with all claims now processing automatically.
There is no model in that system. The claims arrive in a known schema, the eligibility rules are written down, and the portal fields are fixed. Introducing a language model would have added cost, latency, and a failure mode where the system is confidently wrong about a legal document. Deterministic code is the correct choice here.
This is what we mean by applying AI where it earns its place.
The Distinction That Actually Matters
Nearly every operations process breaks into two kinds of steps.
Structured steps have known inputs, written rules, and verifiable outputs. Filing a claim against a schema. Moving a record between systems. Applying a pricing rule. Provisioning an account.
Unstructured steps involve interpreting something a human produced: reading a vendor PDF whose layout changes, working out what an email is actually asking for, categorizing a free-text complaint, summarizing a call.
Structured steps belong to ordinary software. They have belonged to ordinary software for forty years, and ordinary software does them faster, cheaper, and more reliably than any model.
Unstructured steps are where AI genuinely changes what is possible. Before language models, automating them meant either rigid templates that broke constantly or a person doing the reading.
Most disappointing AI projects in operations come from pointing a model at a structured step because the technology was interesting.
Where AI Earns Its Place in Operations
Reading Messy Inputs
The strongest case. Vendor invoices in inconsistent layouts, application forms, emails containing a request buried in pleasantries.
The pattern that works is AI as the reader, not the decider: the model extracts structure, deterministic code applies the rules, a human confirms anything consequential. That arrangement gets the flexibility without handing judgment to something that cannot explain itself.
Triage and Routing
Deciding which queue something belongs in, how urgent it is, or who should see it. These are judgment calls with tolerant failure modes, since a misrouted item gets rerouted.
Drafting Where a Human Approves
First-pass responses, summaries, internal documentation, meeting notes. The human stays in the loop and the cost of a mediocre draft is that somebody edits it.
Search Across Things Nobody Indexed
Answering "what did we agree with this member in 2019" against a pile of documents. Traditional search needs structure that historical material does not have.
Where AI Costs More Than It Saves
- Anything with a schema. If the input arrives in a known shape, write the rules. It will be cheaper, faster, and auditable.
- Financial and legal outputs without review. Confidently wrong is the specific failure mode, and these are the specific places it is expensive.
- High-volume repetitive work with fixed inputs. Per-item model cost against work that deterministic code does for nothing.
- Anything requiring institutional history. If the answer depends on a decision made in 2019 that was never written down, the model will guess, and the guess will be plausible.
- Processes where the rules have never been written down. That is a process-design problem. AI will paper over it convincingly, which is worse than leaving it visible.
The Pattern That Works
In practice, the durable arrangement in operations looks like this:
- Deterministic code as the spine. It carries the volume and it can be audited.
- AI at the edges, where inputs are messy and structure has to be inferred.
- A human at the consequential points, especially before anything irreversible.
The CASH system is a clean example of the spine and the human check, with no edge that needed a model. Plenty of processes do have that edge, particularly anything that starts with a document somebody emailed you. The point is to know which part of your process is which.
How to Tell Which You Have
Three questions resolve most cases.
- Does the input arrive in a consistent, machine-readable shape? If yes, ordinary software. If a human currently reads it to understand it, AI may earn its place.
- Can the rules be written down? If yes, write them. If the answer is "it depends, let me show you," neither AI nor ordinary software will help until that judgment is made explicit.
- What happens if the output is wrong and nobody notices for a week? If the answer is serious, keep a human in the loop regardless of the technology.
The related question of which process to take on first is covered in How to Decide What to Automate First, and the developer-side view of the same tradeoff is in Where AI Saves Real Hours on a Small Dev Team.
A Simple Rule of Thumb
If a person currently has to read something to understand it, AI may earn its place.
If a person is currently retyping something they already understand, that is ordinary software, and it has been ordinary software for decades.
Final Thoughts
The honest answer to "where should we be using AI in operations" is: at the edges, where inputs are messy, with a human confirming anything that matters.
The middle of most operations, the high-volume repetitive work that consumes the day, is usually a deterministic software problem. That is where the largest results tend to be, and it is where our own largest result came from: $450,000 and 13,500 hours, with no model involved.
Being able to generate an agreement from a set of contact information has changed our lives, instead of us having to type each field and everything else.
Lee, Class Action Settlement House
Choosing the boring technology is usually what the payback looks like.
If you are working out where AI belongs in your operation, and where it does not, we are happy to think it through with you. Book a short consult.