Hey!

Chris here. Welcome to Blueprint—the newsletter to help you build a winning engineering team.

I need to talk about determinism. (Side note: There really should be a better, less-nerdy word for this. But I digress.)

In the context of software, deterministic means that if you put something into a system, you'll get the same thing out every time.

This is the principle we've built systems on for decades. The invention of computers and the internet—along with everything we've constructed on top of them—are all deterministic.

But there's always been a conflict here: Humans don't work this way. We behave differently based on the countless internal and external factors that affect us every minute of the day.

And with AI, we've now been given a computer system that also works non-deterministically as we do. And that’s what gives it such enormous potential.

Let me explain why this is such a major shift.👇

📒 DEEP DIVE

The Determinism Boundary Has Lifted

Stop trying to make AI predictable and start using it where ambiguity and variation are unavoidable.

The Instinct Holding You Back

When programmers first got access to AI a few years ago, their response was understandable: "How could this be useful if I can't get the same thing out every time?"

So they did what made sense given what they knew. They twisted and turned it, building elaborate systems of levers and pulleys to try to make it deterministic.

Predictability has always been the prerequisite for usefulness in software, so it makes sense that this was their instinct.

But it's the entirely wrong move with AI.

The Previous Boundary

For decades, there's been a clear dividing line:

• Deterministic systems handle the predictable work

• Humans handle everything else

Historically, when we faced unexpected inputs or a situation that required judgment under uncertainty, we always said these were problems for humans.

And that boundary made sense because humans were the only ones who could handle variation.

But that boundary has been lifted.

Shifting to Principles Over Procedures

We no longer need to hand every unexpected scenario to a human.

Instead of giving AI the answer you're looking for, you can guide its judgment by sharing your decision-making principles and past examples of decisions you made.

Sound familiar? What we're describing is a standard operating procedure (SOP).

A well-built SOP doesn't say "Do this, then do this, and finally do this" in rigid sequence. It gives guidance and trusts the person (or, now, the technology) to apply it to the particulars of a situation.

And here's why: if work can truly be reduced to step-by-step instructions with no variation, it shouldn't involve AI OR humans. It should be automated with deterministic software—something that’s been possible for decades.

The power of non-deterministic systems lies in handling the work that requires judgment when things don't go exactly according to plan.

From Pattern Matching to Intent

The easiest way to conceptualize this shift is with spam filtering.

Before AI, the best we could do was pattern recognition. If certain words appeared in the subject line, the system would flag it as spam.

But that's not how humans identify spam.

A human reading an email can almost always tell you instantly if it's spam. But this has nothing to do with keywords. We're unconsciously assessing intent.

We might use principles like:

• Is this person trying to sell me something?

• Do I know them? Have we talked before?

• What is the purpose of this message?

A non-deterministic system can answer these questions the same way humans do.

And once you can classify intent, you unlock powerful workflows like triage, routing, summarizing, or classification. In other words, the judgment calls that used to require escalation to a person.

Why People Miss the Opportunity

We've spent decades designing systems without this capability.

And now that we have it, people are so used to the old tools that they rarely think about the new one. It just doesn't match the paradigm they’ve constructed.

The essential question has shifted from "How do I make this predictable?" to "What can I do with a system that handles unpredictability?"

Just scratching the surface of what's possible reveals so much opportunity:

• Support triage where every customer issue is slightly different

• Bug classification where context determines severity

• Incident response where the same symptom has different causes

• Lead qualification that requires reading between the lines

So instead of trying to make AI deterministic, use it where navigating ambiguity and variation is inherent to the work—AKA the workflows where you previously needed a person because "it depends."

BEFORE YOU GO…

This week, pick a workflow that's heavy on edge cases.

Write down 7-10 principles that guide how you currently make those decisions, and add 3-5 examples of good calls versus bad calls.

Then feed those to AI and let go of trying to script every possible step.

We've entered a new era where utility, not replicability, is what matters.

It's time you embrace it.

Talk soon,

Chris.