For most of the history of computing, one assumption defined how we interacted with machines:

Computers are deterministic.

Give a computer the same input, and it will produce the same output every time. If it doesn’t, something is wrong. We call it a bug.

This property shaped everything about software, and computers were trusted precisely because they were predictable.

Then large language models arrived.

Ask an LLM the same question twice, and you might get two different answers. And as you already know, it’s not because it’s broken, but because it’s how it is designed. The non-deterministic output of AI is what endeared us to it so much. LLMs made computers remind us of ourselves, and we now sit at the edge of the largest disruption in living memory.

The Rise of Subjective Computing

The way I see it, traditional programs execute instructions, while LLMs generate responses.

Instead of following a fixed path of logic, they predict plausible outputs based on probability.

That means the same prompt can produce different responses depending on subtle factors like phrasing, context, or sampling randomness.

View this post on Instagram

Using these systems feels less like operating a machine and more like collaborating with an assistant.

And as we do with an assistant, if we want them to get us a bottle of water, we don’t say:

• Get up from your chair
• Execute walking function on a bearing of 84 degreess for 10 paces
• Grab water bottle with right hand
• Execute walking function on a bearing of 264 degrees for 10 paces
• Hand me the bottle

Instead, we might just say “I’m thirsty.” Instead of instructions, you express intent.

But Determinism Isn’t Going Away

Despite this shift, computers themselves have not stopped being deterministic: The CPU in your laptop still produces the same output for the same instructions.

And that property is essential, because we rely on determinism everywhere.

When a bank calculates your balance, the answer cannot be creative, it must be correct.

So the future of computing isn’t subjective systems replacing deterministic ones.

It’s a collaboration between the two.

Where Subjectivity Works

Subjective systems are powerful when there isn’t a single correct answer.

For example, a joke can still be funny even if it’s told in thousands of different ways; The exact words may change, but the underlying idea, its “funniness,” can still survive.

LLMs thrive in these domains because they generate plausible variations rather than precise results, and we love novelty.

Where Determinism Still Wins

But many problems require the opposite. When software makes decisions that affect the real world, we need:

• repeatability
• predictability
• traceability

If a system calculates taxes or launches a rocket, “usually correct” is not good enough.

A New Programming Loop

One of the most interesting workflows emerging from AI tools looks like this:

1. A human describes a problem
2. An LLM helps explore and design a solution
3. The result becomes deterministic software

Tools like Claude Code make this pattern explicit.

You can describe a problem conversationally:

“Write a script that parses these logs and calculates error rates by service.”

The LLM helps design the solution, but the final product is still traditional code:

• functions
• logic
• algorithms

Once the code exists, the computer returns to doing what it has always done:

Executing precise instructions.

From Intent to Execution

This creates a new programming loop.

Old model:

Human → writes code → computer executes it

Emerging model:

Human → describes intent → LLM collaborates → writes code → computer executes it

The LLM becomes a thinking partner, and the computer remains the execution engine.

In other words:

We can think with machines before we program them.

I invite everyone to explore AI not just for parsing/interpreting/creating content, but for creating hard cold code. In the end, we’ll always need trusted answers, and getting to them has never been easier.