Category: Style

What Is Non-Determinism, and When Should You Use It?

When all you have is a hammer, everything looks like a nail.

Now that we have AI agents, it’s tempting to have them reason through every step of a task. Check a status? Have the agent interpret a record. Calculate a total? Have the agent read the numbers and tell you what they add up to. Decide whether a customer said yes? Have the agent judge the reply.

The agent can handle all three tasks. The question is how you ask it to do each one. It can check a field, use a calculator, or interpret a conversation. Those choices matter when bots start doing work for you and interacting with your customers. Two concepts help explain why: determinism and non-determinism.

A deterministic system produces the same output from the same inputs under the same conditions. A non-deterministic system can produce different results. Language models are generally non-deterministic, so repeating a prompt can produce a different response. Google’s machine learning glossary

That sounds abstract. Let’s make it practical. Suppose you’re building a bot with this instruction: “When the customer says ‘yes’, move to the next step.”

The user responds, “Yes.”, with a capital Y and period. The app checks whether their response matches all lower case “yes”, so the algorithm misses. You decide to account for capitalization and punctuation.

The next person writes “sure.” Then “okay.” Then “sounds good to me.” Damn! Missed again. You add more rules. Those rules are deterministic. You have explicitly defined which responses will match and what happens when it does.

Then someone writes: “I don’t see why we wouldn’t.” Damn Damn. Got me again.

This is where a language model becomes useful. You can ask it to interpret whether the person agreed, using the conversation as context. You no longer have to anticipate every possible phrase yourself. That flexibility is powerful. It also introduces a different kind of decision into your workflow.

There’s a distinction worth making here: interpreting language, inference, and non-determinism are related in these systems, but they describe different things.

Inference is the process of running a trained model on new input to produce an output. It doesn’t specifically mean understanding someone’s intent, and it doesn’t inherently require non-determinism. For our bot, inference is how we run the model. Interpreting the customer’s response is the task we give it. Non-determinism describes the possibility that its answer may vary between runs.

Keeping those ideas separate helps us ask better questions: where does the ability to interpret justify the cost and uncertainty and what did the customer actually approve?

Consider a few more responses:

  • “Sure, if you can deliver by Friday.”
  • “Okay, but send me the revised price first.”
  • “k”
  • “Yah, sometimes…”

It would take a lot of guess work and lists of hardcoded matches to catch all the ways a person could say yes. So we decide to use an agent for non-deterministic results. Even then, these deserve different treatment. A positive tone can may contain a condition, or no approval at all. “Sometimes” is especially revealing. It does not clearly lay out what approval requires to get to the next step. Even “k” can mean different things depending on what came before it. The agent can interpret the words and the context, but it cannot decide your standard for approval on its own every time. That standard is partly a matter of judgment and policy, and different people may draw the line in different places. Human or bot.

If your bot’s instruction is “look for anything that sounds like positive movement,” you may have built a system that turns interest into permission. The work is in telling the agent what counts as approval for this task, and what to do when the answer is unclear.

For a bot suggesting another article, a loose interpretation might be acceptable. For a bot placing an order, you may want explicit confirmation of the item, price, and delivery terms.

The model’s ability to interpret language doesn’t decide how much ambiguity your business should accept. You have to decide that.

This amazing ability to allow for a great deal of flexibility and variation has changed our world of work. That doesn’t mean every problem requires it now. Model calls consume massive compute, and asking an agent to interpret more information can add cost and wait time. Sometimes that expense buys something valuable: understanding an unusual request, connecting ideas across documents, or drafting a useful response. Other times, the answer is already available as a field, a formula, or a rule. I wrote more on how you can balance agentic power with deterministic costs here.

Let’s use a common email bot helper that many are using to increase productibity today. Suppose you ask your agent to find the messages that need your attention (archiving or deleting all the slop). It could read your entire inbox every time you ask. That gives it plenty of context, but it also takes time and uses inference on messages a simple filter could handle.

Instead, ask your agent to create a filter for the obvious parts of that task. It can easily screen out information from site you like but only when it doesn’t meat pattern you’ve seen. Those filters will (deterministically) trim the data your agent needs to interpret down – sometimes to zero. Then it can read what’s left. The agent still does the work. You’ve asked it to spend its reasoning on the messages that need reasoning. Then you can even add a routine to have it create filters based on probably patterns it’s deleted without reading. Each run decreases costs.

Using the customer confirmation example from before, I’d redesign the handoff like this: Have the model interpret the reply as approval, rejection, conditional approval, or unclear. You can even include definitive reply patterns to increase speed and save a cent or two each run.

  • Ask you dev agent to create a deterministic list of positive exact match cases that ignore periods and captialization.
  • Provide explicit non-deterministic rules to understand what each category should permits.
  • Ask the user for clarification when a condition or ambiguity affects the next action.

The filter trims the use of the model, model helps interpret the conversation. The rules establish what the system may do with that interpretation. That’s the design decision that deserves more attention as we put agents to work. Thinking, along with the agent, while developing or setting up our personal bots saved the world time, energy, air quality, speed, cost, and more.

Every request for interpretation should earn its place. What ambiguity is the agent resolving? What flexibility are we gaining? What happens when its interpretation is wrong? How can I trim the list of variations with certainty first? An agent can build and run the whole workflow, including creating the filters, lookups, and calculations that let it focus its judgment where it counts.

Knowing when to remove from you agent with your agent, implement with your rules your agent can reason with, and when to have it check back in to be sure, is part of using all the tools on your toolbelt based on what works best.

Cheap Code Doesn’t Change What a Product Is

“If AI can rebuild your product in a weekend, why would anyone pay for it?”

I hear this question just about every single day on X, Instagram, Reddit and more. It sounds like a question about the future of software. But underneath it is an old assumption: that what people buy when they buy software is the code.

If that were true, cheaper code would make the whole business fall apart.

But think about what you’re actually buying.

When you pay for a scheduling tool, you aren’t looking for access to a calendar interface. You want to stop emailing people about when they’re free. You want the invitation to arrive, the time zones to work, and the meeting to show up where it belongs.

You want something taken off your plate.

The code is part of how that happens. It isn’t the whole transaction.

You could make the brownies, too

I wrote about this in Convenience Is the Product.

Brownie mix is a simple proposition. Someone measured the ingredients, worked out the proportions, and put the instructions on the box.

You could do those things yourself. Buying the box doesn’t mean you couldn’t.

It means you’d rather spend your attention somewhere else.

Software has a similar bargain. Someone has decided how a process should work, which details matter, and what you shouldn’t have to think about.

AI changes how much effort it takes to make your own version. That matters. Some things you used to buy may become things you make.

But the ability to make something doesn’t automatically create the desire to be responsible for it.

A weekend is only the beginning

Let’s say you rebuild your scheduling tool this weekend.

It works. You connect your calendar, send a link, and book a meeting.

Then someone asks to reschedule. Someone else needs different availability for different kinds of meetings. Your team wants shared bookings. An integration changes.

Now you have a second job.

Maybe AI helps with all of it. Maybe each change takes minutes. You still have to notice the problem, explain what should happen, decide whether the result is right, and care enough to keep doing it.

That’s a different commitment from making something work once.

“Can I build this?” and “Do I want to own this?” are two different questions.

A product earns its place when the answer to the first is yes and the answer to the second is no.

The decisions are part of the product

There’s another layer here.

A useful product contains decisions you may never notice. What happens by default. Which options appear first. Which exceptions are supported. Which requests get turned down because accommodating them would make everything else harder.

Those choices give the product its shape.

This is what I explored in What You Won’t Do Defines You. Refusal is part of making something coherent. Every possible addition isn’t an improvement.

Cheap building makes that discipline more valuable. When you can produce five versions quickly, you still need a reason to choose one.

AI can help you consider the options. It can even recommend a direction. But someone still has to commit to what the product is for and accept the consequences of that choice.

As I wrote in Indecision Does Not Preserve Options, leaving a question open creates work of its own.

Being able to build every option doesn’t make every option worth building.

That doesn’t mean your business is safe

There’s a distinction worth making here.

People continuing to need software doesn’t mean they will continue to need yours.

If a competitor can reproduce your features and take the same burden off the customer for less, you have a real problem. Saying “we sell convenience” doesn’t answer it. The competitor can sell convenience, too.

And if a customer can make a version that takes almost no effort to maintain, buying yours may stop making sense.

Cheaper building changes those calculations. It puts pressure on what you charge and how much value you deliver.

But it doesn’t erase the underlying transaction.

You still have to understand a problem well enough to make useful choices about it. You still have to deliver the result reliably. You still have to keep earning the customer’s preference as their needs change.

The argument for starting a software company can’t be “people will always need software.”

It has to be: “There is something here people would gladly pay us to keep handling.”

What are you taking off their plate?

That’s the question I’d spend more time on.

How much does your customer still have to figure out? How often do they have to check your work? When something changes, who notices? Who deals with it?

A product can have a hundred features and leave most of the burden with the person using it.

Another can do one thing so completely that the customer barely thinks about it again.

That second product has a reason to exist, even in a world where its code is easy to reproduce.

The customer may know exactly how to build it.

They may even enjoy building it.

And still decide they have something else they’d rather do with their Tuesday.

That’s what you’re competing for. Not just the cost of making the software, but the value of everything your customer would rather spend their life doing.

Cheaper code changes what they can make.

Your product has to earn what they’re willing to hand off.

Indecision Does Not Preserve Options

Product bloat is often blamed on too many ideas or not enough resources to get speed. More often, it comes from too few decisions catching up with you.

A team delays deciding if a feature is required, who it is for, is the value it brings worth it to the overall product and company stage. The team hopes that time is saved by moving on to the next feature or issue will speed them up or “fix it”. The unanswered question feels like a temporary issue that doesn’t deserve time because there is not enough time for it. The work can continue. But nobody has removed the question. They have simply created compounding overhead.

So, “for now”, the feature will; to serve anyone.

It gains settings for one interpretation, exceptions for another, and workarounds for the cases nobody wanted to rule out. What began as an effort to stay flexible becomes a product that asks its users to carry the uncertainty the team did not resolve. The cost is not limited to one vague feature.

Imagine five possible directions: A, B, C, D, and E. None has been decided. It can feel as if the team has preserved five options. In reality, it has created five active futures.

Each future produces its own downstream work. Each has dependencies, edge cases, and failures. If something breaks deep inside E, the question is not only whether to fix it. The team also has to decide whether E is still important, whether it will matter later, and whether that work should take priority over something developing in A or D.

The original decision has been deferred, but the decisions it created have multiplied. This is why indecision becomes so expensive. It divides attention before it divides the product.

A person can be actively working on a branch that should never have existed. A customer can arrive with a real need for D, but the team may not notice it clearly enough because everyone is already carrying the mental load of A, B, C, D, and E. Attention is scattered across possibilities. Problems demand responses. Opportunities arrive without enough clarity to be recognized.

Eventually, the cost becomes visible in the product itself.

Flowchart illustrating the consequences of indecision with five options (A, B, C, D, E) leading to divided attention, increased work, and ultimately product bloat.

The interface gets crowded. Navigation expands. Settings multiply. A straightforward path becomes a collection of tabs, filters, alerts, roles, exceptions, and competing actions. Each piece may have a history. Each may have made sense at the moment it was added. Together, they create a product that feels fat, difficult, and strangely hard to simplify.

By then, teams often describe the problem as technical debt, feature creep, or complexity. Those descriptions are true, but they are incomplete. The product is carrying the consequences of decisions that were never made. This is also why rebuilding can be so valuable.

Starting over is usually treated as a dangerous impulse. There are real things to lose: working behavior, unusual customer needs, knowledge embedded in old systems. The fear is understandable. The first version contains too much history to dismiss casually.

But rebuilding is not about pretending that history did not happen. It is about forcing history to justify itself.

When a product is rebuilt, every feature has to earn its place again. Every workflow has to explain why it exists. The old assumptions no longer receive automatic authority simply because they have been in the product for a long time.

Some things should carry forward. Many will.

But some complexity only survives because nobody has paused long enough to ask what it was protecting. The things that melt away during a rebuild are often the most revealing. They are not necessarily mistakes. They are artifacts of uncertainty that became permanent by accident.

The first version teaches the team what it did not know. The next version has the chance to decide.

This does not mean every unanswered question needs an immediate answer. Uncertainty is real, and sometimes waiting is the right decision. But waiting should be a decision too. It should have an owner, a reason, and a point at which the team comes back to resolve it.

Otherwise, the product will resolve it for you. And it will do so by getting bigger, slowler, and unruley.

A case study in logo animation with AI

I wanted to experiment with animating a logo using agents I already had. The results surprised me. I’m glad I stuck with it, and I hope sharing the process saves you some time.

I’m not an animator, but I’ve been interested in animation for a long time. In school, video editing classes brought together my love of art, expression, and cartoons. I was fascinated by stories about how Disney and its animators thought. I made things using tools like Flash, Maya, Blender, and Final Cut. I learned that a bouncing ball is more than a ball moving up and down. Animating it meant understanding speed changes through easing and how mass affects the way a shape moves, squishes along both axes, and springs back.

Purpose built animation apps

I started by trying third-party tools that promised to make animating a logo easy. I tried Adobe, Canva, and even apps built specifically for logo animation. They were all unimpressive. At best, they added a shake or an expansion, but the motion had no character. It felt like AI’s equivalent of PowerPoint clip art. I had little control over how the animations could make use of my logo’s unique qualities. Even Lottie, a first-class web animation tool, didn’t offer a way to upload my logo and create a timeline animation for me.

Open AI

Next, I tried ChatGPT. I’d seen it do impressive things with image generation and art, so I started with a process that had worked well for me when brainstorming image ideas: a storyboard grid. You can read more about that here.

I asked for a 5-by-5 grid, with each row showing a different animation and each cell representing a keyframe: an important pose or moment in the movement.

A 5x5 grid displaying motion study concepts for logo animation, featuring visual representations for each animation idea like 'Breathe', 'Elastic bounce', and 'Magnetic assembly'.

The idea showed promise. After a few experiments, I picked my favorite animation to develop.

From there, things went downhill. GPT produced animations that bore little resemblance to the storyboard. I tried different instructions and output formats, including GIF, SVG, and Lottie. It felt like it would take a lot more turns and tokens to get to something worth celebrating.

Magnetic assembly animation with four pieces coming together and separating.

Give up or fight on

I subscribe to several AI tools because one of them may have a feature that works especially well for a particular task. I use Cursor, Grok, Claude, and OpenAI regularly. That day, after getting nowhere with the third-party tools and OpenAI, I gave Claude a try. A few weeks earlier, it had handled a tricky image request in one turn, while the others took several tries and still didn’t produce anything usable.

Claude

Claude’s first animation attempt was far better than the others. It decided on its own to use animated SVGs, and it worked. It was a unique animation made for my logo. It wasn’t ready to use, but it gave me hope. If it could get that close from a loose prompt, maybe it was worth giving it more time.

During the earlier attempts, I’d started describing parts of the logo as if they belonged to a character: “The top two nodes are hands, and the bottom two are feet. Change the right hand like this.” Then I imagined the logo getting bored from sitting in a website header all day. It might slouch, nod off, or let out a big yawn, so I asked for a yawn animation. Here it is as an animated GIF.

A stylized red plus-shaped logo with rounded edges.

Here are a few tricks I learned to take the animations further with less pain.

Storyboarding

Don’t just create a storyboard to guide the animation. Ask for one with each generated version. With the storyboard, I could point to a specific frame and annotate the change I wanted. For example, I wanted the logo’s “hands” to reach farther out and shake in frames 32 and 33.

Grid of pink shapes with text labels indicating various actions and time durations.

It also let me fix small details that would have been hard to specify. I noticed a tiny bulge between a node and its stem. I could target the frame and circle the bump so Claude could fix it. It used that feedback well, resolving the issue without regression or confusion.

Two similar abstract red shapes with a central round area, one shape has a marked detail at the top left, and the other has a marked detail at the top right.

Use reference material

When I watched behind-the-scenes footage of Disney animators, I loved seeing how they studied animals in their environment and asked actors to perform for them.

That memory came to mind when I tried to create a jumping-jack animation but wasn’t quite getting the nuances I wanted. Instead of trying to draw or verbalize what I meant in a storyboard, I showed the agent a human reference so it could understand the nuances I wanted to capture in the movement.

A sequence of three illustrations showing a person performing jumping jacks, demonstrating arm and leg movements.

Unlocking words

That was much easier than describing the change in another prompt. I also found that a broad direction like “give it life” could lead to subtle movements I might not have thought to specify.

Claude’s animation work clicked for me. Codex’s did not. The experiment reminded me how much I could contribute with visual references and an understanding of movement, even without being an expert. The agent created possibilities, and the storyboard gave me a way to direct them.

Knowing the rules free you from them

Mastery begins when you understand why the rules exist, and when they no longer apply.

There is a moment in learning almost anything when the rules that helped you become competent start getting in your way.

But fighting doesn’t happen inside a doctrine. It happens between two human beings, in circumstances that cannot be entirely anticipated.

In this interview, Bruce Lee discusses how martial arts develop styles, doctrines, and prescribed ways of fighting. Eventually, the doctrine becomes more important than the purpose it was created to serve.

Lee’s philosophy was to move beyond rigid styles and respond naturally to the situation in front of you.

That idea extends far beyond martial arts.

When knowledge becomes a constraint

When we’re inexperienced, rules are incredibly useful. They compress someone else’s experience into something we can follow. A designer learns composition. A musician learns scales. A programmer learns patterns. A manager learns frameworks.

This is how expertise begins.

But there’s a subtle failure mode. We can become so good at following the rules that we forget why they existed in the first place.

A technique is supposed to solve a problem. Eventually, we start treating the technique itself as the solution.

This is particularly obvious in art.

A young girl in a white dress and veil kneels at a church altar, reading from a prayer book. A mature man, possibly her father, stands beside her, while a priest in red vestments prepares a ceremony. The scene is set in a dimly lit church with candles and floral decorations in the background.

Picasso was an accomplished traditional painter before helping pioneer Cubism. Jackson Pollock studied traditional drawing and painting before developing his famous drip technique. Their departures from convention were informed by an understanding of the conventions themselves.

The distinction matters. Breaking a rule because you don’t understand it is quite different from breaking it because you understand its limitations.

A large mural featuring abstract figures and forms in shades of black, white, and gray, depicting scenes of chaos and suffering.

Great artists aren’t necessarily rejecting what they’ve learned. They’re exercising the freedom that comes from having learned it deeply.

The difference between someone who can reproduce a technique and someone who has mastered a craft is often the judgment to know when the technique no longer applies.

The problem with best practices

You see the opposite in workplaces all the time.

Someone learns a management technique, a product framework, a sales methodology, or an engineering practice. It worked somewhere, so they implement it exactly as they were taught.

Then reality gets involved.

The customer is different. The team has different capabilities. The constraints have changed. Yet instead of adapting the technique, we often blame the people for failing to execute it correctly.

We’ve confused adherence to a process with the purpose of the process.

Book cover of 'Creativity, Inc.' featuring a red background with a silhouette holding a pencil. The title and author's name are prominently displayed.

Ed Catmull explores a similar problem in Creativity, Inc., describing how Pixar developed processes to support creativity while recognizing that no process could guarantee a successful film.

The process was there to help people exercise their judgment, not replace it.

That’s a distinction many organizations struggle to maintain. A successful practice becomes a best practice. Best practices become policies. Eventually, people are rewarded for following procedures rather than producing the outcomes those procedures were designed to achieve.

Ironically, the very practices that once helped an organization succeed can become obstacles to its progress.

The freedom of understanding

There’s a philosophical dimension to this as well.

Nietzsche challenged the tendency to inherit established values and conventions without examining their origins or legitimacy. His philosophy encouraged individuals to question received assumptions and develop their own understanding rather than simply accepting what tradition prescribed.

This doesn’t mean that established knowledge is worthless. Quite the opposite. We need accumulated knowledge to avoid rediscovering everything ourselves.

But inherited knowledge is a starting point for judgment, not a substitute for it.

And that may explain why genuine expertise is so difficult to teach.

You can teach someone the mechanics of a craft. You can provide frameworks, examples, and procedures. What is much harder to transfer is the understanding underneath them.

The part that recognizes when circumstances have changed enough that the established approach is no longer appropriate.

This is where experience becomes wisdom.

Experience gives us examples of what has worked. Wisdom gives us the ability to reason about why it worked, and whether it should work again.

Mastery is not obedience

Perhaps the greatest misconception about mastery is that it means knowing all the rules.

In reality, the rules are only approximations of the deeper principles we’re trying to understand. They’re useful because they simplify complex problems, but that simplification inevitably leaves something out.

The beginner needs the rules because they haven’t yet developed the judgment to operate without them. The expert understands that the rules were never the ultimate objective.

This is true whether you’re creating art, building a company, writing software, or practicing martial arts.

The goal of learning is not to become someone who follows every rule perfectly, nor someone who proudly ignores them.

It’s to develop enough understanding that you can respond to the problem itself, rather than merely following the instructions someone else developed for a different problem.

That’s the freedom that comes with mastery. And when you get their true purpose you can finally benefit from the teaching.

Convenience Is the Product

Look in your pantry.

A surprising amount of what we buy is something we could have made ourselves.

Cocktail sauce is a good example. The basic idea is remarkably simple: tomato-based sauce, horseradish, vinegar, seasoning. (Heinz) Worcestershire sauce is a much more elaborate fermented condiment, but even it is ultimately a collection of ingredients and processes that could theoretically be reproduced at home.

Brownie mix makes the point even more clearly. A typical boxed mix is largely sugar, flour, cocoa, and a handful of other ingredients. Betty Crocker’s current mixes make the composition almost comically obvious on the label. (Betty Crocker)

Yet we buy these things and we fill our pantries with them.

The interesting part is that we are not really buying the ingredients. We are buying the time someone else spent assembling, measuring, packaging, testing, preserving, distributing, and explaining them.

That is convenience. And convenience is a much more fundamental concept in business than we usually give it credit for.

A business exists, in most cases, because there is something someone needs to do that they would rather not spend their own time doing. Even if you are buying a skill you don’t have, you are actually buying the time to have to learn that skill yourself.

Sometimes the thing takes skill. Sometimes it takes equipment. Sometimes it takes capital. Sometimes it takes experience. Sometimes it is simply annoying. And sometimes it takes five minutes away from what you would rather do. So you pay.

It doesn’t matter if it is software, AI, consulting, manufacturing, or physical labor. The implementation changes, but the underlying transaction is consistent.

This may sound like a shameless plug but it is truly the basis for why I published this in a kids book called Erec Makes a Fire almost 10 years ago. The story is intentionally simple because the underlying idea is simple and it is better to ingrain it in a child than repeat it to all the adults. Erec needs to accomplish something, but accomplishing it requires time and effort. The people around him each have different capabilities, and things they spend time doing.

Someone has a problem they could solve it themselves. You make it take less time and they pay you.

This is one of the reasons I think we sometimes misunderstand innovation.

We tend to imagine a business as creating something that did not exist before. That is certainly one kind of business. In reality 99.9% of the time, it’s a derivative. And for good reason – but not this post’s point.

A business takes something that already exists and make it easier, faster, cheaper, closer, reliable and/or understandable.

More convenient.

The product may look like software, a bottle of sauce, a box of brownie mix, or a person showing up at your house with a toolbox. Underneath, the value proposition is the same.

I will spend my time on this so you can spend yours on something else.

And that is actually a beautiful feature of an economy. We do not each have to become good at everything. We don’t need to astound the world with something never seen before. We don’t need to “innovate” beyond what customers have or need.

We are all simply and constantly buying back pieces of our own time. And that has scaled in layers for thousands of years.

The strange thing is that we often forget this when we talk about technology. We ask what AI can create, what software can automate, or what a new company has invented.

A more useful question is often much simpler:

What does this allow someone to stop spending their time doing?

That is where most of the value lives. The product is not always the thing in the box. Sometimes the product is the five minutes you just got back.

When Determinism Is Better Than AI

AI’s superpower is creating deterministic products.

We have become fascinated with AI’s “human-like” level of non-determinism. “I’ll just let AI handle it” is quickly becoming a default answer to problems we haven’t fully thought through, because if AI will figure it out, why should I?

One can ask a chatbot almost anything and marvel at what comes back. Give it a problem and it can find a path you did not anticipate. That unpredictability is part of what makes AI amazingly intelligent, and in many situations it is exactly what makes it the revolution in technology we dreamed of for decades.

But in some cases, we are using a sledgehammer to tap in a nail, and it is costing us a chance to provide the right solutions.

When delivering software as a product, the majority of products are not trying to surprise their users to provide value. Creativity sounds universally desirable, but humans require a surprising amount of consistency to be productive. We don’t generally ask our employees, engineers, doctors, lawyers, or PhDs to be randomly creative. We give them a mission, constraints, and some expectation of what a good result looks like. We want coffee on Tuesday morning at 9 AM, even though all the data points otherwise. Random human + informed AI + creative decisions = unhappy people.

AI doesn’t escape our expectations simply because it is intelligent.

A system that generates a different answer every time it is asked and is told to respond in certain ways with generalized prompts can aspire to be remarkably capable, but it can also be remarkably difficult to control, test, explain, package, interpret, and trust.

I don’t say this philosophically. I say it after years of wrangling AI to do things I hoped would create uniquely powerful products that didn’t exist. Why are the products we see so bad at converting this powerful tech into a powerful value prop? “SaaS is dead” encapsulates that problem. Copying and pasting your work into ChatGPT is often better than using a packaged product that tries to leverage the same AI to complete expected tasks efficiently or effectively. Chat is a bit messy, but it leans into that via the chat experience. That messiness is at odds with a packaged product.

I hear it every week from some aspiring entrepreneur: “Give the AI all your data and let it discover and manage [insert problem here].” It is a magical proposition that is within reach now.

Often it can turn into amazing demos and show unbelievable potential. But getting from a controlled demo to a reliable set of actions and outputs, unmonitored and unaudited by a human, is exceptionally hard. Even big companies with big wallets struggle with the transition. Small amounts of drift compound. Mistakes require review. Sometimes understanding what the AI produced takes nearly as much human effort as doing the work yourself, even if the human would have done the work somewhat worse. And don’t get me started on the cost of answering questions with non-deterministic expectations.

Perhaps we solve this. I hope we do. But in building these systems, I came to appreciate another application of AI that I think we’re underestimating.

Allowing the average person to let AI run their business may be a few years away. Building a business or product with AI tooling is already extraordinarily powerful, and not merely because AI lets us build software faster. It lets us afford complexity we previously couldn’t.

Historically, software has been deliberately simplified.

If a problem had a thousand paths, we rarely implemented a thousand paths. Humans had to anticipate the main cases, write the rules, implement them, test the edge cases, and maintain everything afterward. Eventually the economics would win. We scoped down to three possibilities and ignored the rest so that the software would work well for those cases, slowly building up one case at a time as needed.

AI changes the economics of that equation.

We can now use non-deterministic development tools to explore an enormous possibility space, then turn what we learn into deterministic software. A function that would take an immense level of brainpower to create efficiently, effectively, and robustly was expensive to build, let alone maintain as features were added. Now AI not only helps discover the paths, but can create elegant, hardened functions that deterministically handle all the possibilities you give it. Changing that functionality is no harder.

That distinction is more powerful than it initially sounds.

The power is in the fact that humans don’t typically expect to give or get thousands of outcomes from certain problems. Time and time again, we imagine a waterfall of possibilities when reality only requires an eyedropper’s worth of water.

Because of this tendency to overestimate the useful possibility space, 100 possibilities handled deterministically can feel remarkably intelligent. And with static, scalable, deterministic code, you are paying an infinitely smaller cost to solve these problems. It really is the best of both worlds: scalable software, intelligent-seeming computations, and extraordinarily low complexity to build and manage.

We get much of the richness we associate with AI without requiring an AI to improvise every interaction.

This isn’t an argument against live AI. Some problems genuinely benefit from open-ended answers. Chat obviously does. Search, research, documentation, creative work, and assistance are natural places for a system that can respond to questions nobody anticipated when the product was built. I have five bots running all the time to manage my email, calendar, video creation, socials, and more. They need slapping around now and again and require a lot of guidance, but they are far cheaper than hired help and always running 24 hours a day.

The thing I think nine out of ten people miss when the silver-bullet dream of AI is presented is this: infinite possibility isn’t a requirement for every problem.

Often the customer knows what they are trying to accomplish. Most consumers don’t need an infinite number of possible answers for the mountain of information that surrounds them. They need a sufficiently large number of great ones that consistently provide value.

That is the subtle opportunity I missed when I first started building heavily with AI. I was fascinated by AI’s ability to make software non-deterministic. I now think its ability to make deterministic software vastly more expressive may be just as important.

AI has dramatically lowered the cost of deliberate complexity.

Instead of asking AI to decide what our product should do every time it runs, we can use AI to help us consider far more of what it could do while we build it. We can then deliberately decide which of those possibilities it should handle and save ourselves and the customer more money than they thought possible.

The intelligence moves from improvising the product to constructing it.

And sometimes that is exactly where you want it.