Category: ai

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.

Think in Sprites When You Generate Images with GPT

Here is a useful trick if you are generating a lot of small graphics with GPT.

Not every image you need actually needs to be generated as a standalone image.

A small icon, avatar, button state, game asset, UI decoration, or other graphic may only occupy a tiny amount of your final product. But image generation systems often work at resolutions much larger than the thing you actually need. ChatGPT Images now supports different aspect ratios and resolutions, but you are still generating a relatively large image for a relatively small object. Larger image outputs generally consume more image tokens and can take longer to generate. (OpenAI Help Center)

So think like a game developer from the 1990s. Think in sprites.

A sprite sheet is simply one image containing many smaller graphics. Instead of loading 100 individual images, a game could load one image and tell the graphics system which rectangle of that image contained the sprite it wanted. The browser or game engine would then display only that portion.

The same idea works surprisingly well with AI image generation.

1. Generate a grid instead of individual images

Suppose you need 20 tiny cartoon avatars for an application.

You could ask GPT to generate 20 images. That means 20 generation jobs, 20 waits, and potentially 20 times the generation overhead.

Instead, ask it for a grid:

Create a 10×10 grid containing 100 unique cartoon avatars. Each avatar should occupy exactly one cell. Keep the visual style consistent, but make every character distinct. [what you want the images of – in the case below clubhouse dressed, 2d, comic style, animals]

You now have one generated image.

Then split the image into its cells yourself. This is trivial with an image editor, a tiny script, or even a second AI-assisted step in your agentic environment.

The important part is that the generated image is now the container, not the final asset.

You can do the same thing for icons, illustrations, characters, graphics, UI elements, or almost anything where each individual asset is smaller than the generation system’s useful output size.

Here is an example of one I iterated on for a hobby project at http://www.skillbase.club where we made the theme country club based on the domain we could get.

A collage of illustrated animals wearing sports attire, including hats and vests, each with a unique expression. The animals include a variety of species such as birds, mammals, reptiles, and aquatic creatures.

That’s 100 avatars for the same time and token cost as a single oversized image.

2. Use grids for drafts, too

This is arguably the more useful trick.

Maybe you don’t need 20 images. Maybe you are trying to decide which version of one image you actually want. Instead of generating four separate versions, ask GPT for a 2×2 grid:

Create four variations of the same clubhouse in a 2×2 grid. Keep the subject identical, but make each cell explore a different composition. [or name each composition like Lichtenstein-esque or paper cut out]

Now you can compare four directions in a single generation.

Once you pick the winner, generate that one properly.

A large, elegant house with a spacious front porch and manicured lawn, set against a clear blue sky.

This changes the economics of experimentation. You are using the expensive, slow part of image generation to explore a space of possibilities, rather than paying the full cost to explore each possibility independently.

And there is a broader lesson here.

We spent decades learning to optimize graphics by separating the asset from the container used to transport it. AI image generation makes it easy to forget that distinction.

If you need something small, generate a sheet. If you need alternatives, generate a grid. Then cut out what you actually need.

Socratic AI: The debate-based Writing Method to create better content

When asking AI to write articles, I think most people prompt apps to “Write about this…”. They provide some details about what to write, more or less, and then use AI to help with the editing. It’s a kin to having an editor or ghost writer.

I started in the same way, but always felt like I was battling the AI instead of working with it. I’ve come to use it very differently. Not do I love this new method but I learn a lot from the experience each time.

Instead of asking AI to write for me, I use it to think through concepts with me. To have it debate or question my thoughts. To specifically “not write an article” for quite some time until I think we are on the same page. This can sometimes take weeks strewn with small chats with long breaks in between until a new thought spark up again.

This whole approach started by accident when I discovered more personality with GPT 4. One day I got riled up from reading some shallow post. It sparked a mental argument with myself to try and see how “the other side” could come to such a different conclusion. On a whim I gave ChatGPT a chance to give me the other side and it surprised me. It not only delicately agreed with my POV, but it gave another potential position followed by “if you could change the circumstance how would you do it?”

It didn’t just echo my points. It pushed back. It made counterarguments. It sharpened the conversation. I ended up having a long conversation with the AI. By the end of it, I understood my own idea better. I felt like I had a smart, patient thought partner who genuinely got what I was trying to work through. It was mind blowing.

That’s when it hit me. If GPT can do this with abstract ideas, why not use the same kind of back-and-forth to help me write?

That’s how this process was born. I’m not starting with a goal to create a draft. I’m starting with a goal to think through a conversation and see where it leads.

What I’ve found feels like a modern revival of the Socratic dialectic. It gives me a space where I can toss out half-formed thoughts, question assumptions, test ideas, and refine them through dialogue. Some go nowhere, but all end with a better grasp of my original thought or counter thoughts.

I keep all my writing in a single project so GPT has context from everything I’ve written or said before. When I want to explore something new, I open a fresh thread and say:

“I don’t want anything created yet. I want to jot thoughts down and then I’ll let you know if I’m ready to create something or if I want to dig deeper.”

Then I just post whatever comes to mind. No outline. No goal. Just the original vapor of a concept. Sometimes I ramble. Sometimes I loop back or take side paths. Sometimes I ask:

“What do you think?” or “Is there a counterpoint I’m missing?”

And it responds. Not with a final draft, but with friction. With momentum. With more angles to explore.

I think best in conversation. I rarely find clarity in a vacuum. Often I will argue a point with someone and walk away with a whole new version or perspective on my belief. Often, I push on ideas, debate myself, and churn.

So when GPT became more conversational, it clicked. It felt like I finally had a thinking partner who didn’t judge, remembered everything, and has no distinct side. The result isn’t just better writing. It’s better thinking.

Once the idea has been explored enough, I ask GPT to turn the thread into an article. Since it has been there for the full conversation and already knows my tone from past articles, the first draft usually comes back pretty close to what I want.

It is never final, but far more inline and final than anything I have ever tried to create with AI before.

Once I am done I end the thread with my final post in my project:

“Here’s the one I actually used. Save this to memory. No more feedback or follow up needed.”

Over time, it learns me. My tone. My rhythm. The kinds of lines I keep, the ones I cut, and the ones I repeat for emphasis. It becomes both a mirror and a co-writer.

So no, I don’t start by asking GPT to write something. I start by asking it to listen. To push back. To help me think through things better. This isn’t AI-assisted writing, it is AI-assisted dialectic.