Deterministic AI Architecture: Let the Model Judge, Not Compute (Simply Explained)

The Day AI Handed Me a Confident, Beautiful Lie

I was building a system for a personal-injury law firm. Its job was to read messy intake notes and tell the lawyers how much time was left before a legal deadline ran out.

I made a mistake. I let the AI calculate the deadline itself. It came back with a clean, specific answer: a certain number of days remaining. It looked official. It looked right.

It was off by months.

Here's what scared me. There was no warning sign. No error message. No "I'm not sure about this." Just a tidy number any reasonable person would have trusted. In a law firm, a wrong deadline that looks right isn't a small bug. It's the kind of mistake that ends a case and sinks a firm.

That moment taught me the rule I now build everything around. A wrong number that looks right is far more dangerous than an error message. You catch an error. A confident fake walks right past you.

What I Actually Do Instead

The AI I use is brilliant at reading and judging. It's terrible at arithmetic you can trust. So I stopped asking it to do both.

Think of it like a courtroom. The AI is a sharp paralegal who reads piles of documents and pulls out the facts. The calculator, the part that does the actual math, is the accountant. You'd never let your paralegal guess your tax bill. You let them gather the paperwork, then a calculator does the math.

That's the whole idea. The AI reads, classifies, and extracts facts from messy text. Plain old code handles anything with one correct answer. Dates. Penalties. Totals. Money.

It sounds obvious written down. Almost nobody builds this way.

Here's why it matters. AI is built to produce plausible-sounding text. That's a feature when you want creative judgment. It's a disaster when you want a number a court will see. Better AI doesn't fix this. Better AI just lies more convincingly. So I never trust it with the math. I put a wall around it.

How I Fixed the Deadline System

Here's the right way to build that law firm tool.

I gave the AI exactly one job: read the intake notes and pull out a single fact, the date the incident happened. That's it. Reading messy notes and finding a date is something AI is genuinely reliable at.

That date then feeds into a table of legal rules that a human built and maintains. The table says how long each type of case has before its deadline. Then plain code takes the date, looks up the rule, and counts the days. Simple math over a known rule.

The AI never touches the math. It doesn't even know the rules exist.

There's a second benefit that matters more than people expect. A paralegal can open that table and read the rules in plain English. A partner can confirm the system follows the law correctly without knowing anything about AI. The rules aren't hidden inside a mystery box. They're a table anyone can check.

Catching the AI When It Makes Things Up

Same firm, different problem. AI makes up legal citations all the time.

And it's good at it. It'll produce a case name that sounds real, a reference formatted perfectly, every surface signal screaming "legitimate." The case doesn't exist. Real lawyers have been punished by courts for filing documents full of these fake citations. It's a known, documented disaster.

You can't fix this by asking the AI to be honest. It doesn't know it's lying, because it doesn't really know anything. It just produces text that sounds right.

So I built a checkpoint. Every citation the AI produces gets checked against a real legal database before it goes anywhere near a document. If the case can't be confirmed real, it doesn't get a warning. It gets thrown out. It never reaches a human.

I treat every unverified citation as fake until proven real. Guilty until proven innocent.

I use the exact same trick in my own DTC fashion brand in San Diego to stop the AI from inventing products that don't exist. Different business, identical move. You don't ask the AI to stay inside the lines. You build a wall so it physically can't ship anything outside them.

When Real Money Is on the Line, AI Doesn't Get a Vote

Here's a case where I kept AI as far from the numbers as possible: a California labor-compliance tool I built for a software client.

California wage law is brutal math. Overtime thresholds, break penalties, fines that stack in specific legal ways. Every violation maps to an exact dollar amount the law decides. There's one correct answer for any timesheet.

The AI's only job was cleanup. Timesheets show up in a dozen messy formats. Spreadsheets, scanned PDFs, handwritten notes someone typed up. Reading that mess and turning it into clean, organized data is exactly what AI is good at.

So the AI reads the mess and hands off clean data. That's where its job ends. Then plain code does every penalty calculation, following the law step by step. The AI is nowhere near the arithmetic.

Why so strict? Because a made-up penalty number in a compliance tool is two disasters at once. The customer might act on a wrong figure in a legal case. And the vendor loses all credibility, because the entire point of the tool is that the numbers are correct.

You don't get to be approximately right about a legal penalty. You're right, or you're worthless.

The One Question That Decides Everything

Here's the test I use to decide where AI stops and code starts.

A partner looks at a case score and asks, "why is this a 72?"

If the math lives in code, I can show the exact arithmetic. This factor scored a 4, weighted this much, adding this to the total, and here's every other piece. The number is defensible line by line.

If the AI did the math, the only honest answer is "the AI said so." That's not good enough. It's also unfixable, because if the number's wrong, there's no step to correct. You're just hoping the next version does better.

So here's the rule: anywhere a human will need to explain or defend a number, that number has to come from code you can trace.

If you're a CEO who's said "AI is too unreliable for the high-stakes stuff," you're right about the risk and wrong about the conclusion. The answer was never to avoid AI. The answer is to use it only for what it's reliable at. Reading. Judging. Extracting. And keep it far away from any number where being confidently wrong is a catastrophe.

The AI reads the intake. My code computes the deadline. The AI cleans the timesheet. My code calculates the penalty. At no point is a number that matters left to a guess.

Most vendors who burned you did the opposite. They let the AI do the math, shipped pretty wrong answers, and called it innovation. It demoed beautifully. Then a number was wrong in a way nobody caught until it cost something.

When I build a system, that line between judgment and math is the first thing I draw. Before anything else. Because if you get that line wrong, nothing else can save you.

Thinking about AI for your business?

If this resonated, let's talk. I do free 30-minute discovery calls where we look at your operations and figure out where AI could actually move the needle, and just as importantly, where it shouldn't go anywhere near your numbers.

Book a Discovery Call