The two bad extremes of AI

Most great technology polarizes. AI has also polarized people into 2 broad groups:

• who assume AI is a silver bullet for everything.

• who think AI is mostly useless, use it only for dumb stuff, or refuse to use it at all as a matter of principle.

They are both wrong.

I found myself in a 3rd group, and it's led by great people like Linus Torvalds, so i might be at the right place :)

Over time i've evolved an interesting way of deciding when to use it. And that's what i wanna share in this article.

How automation worked before: specifiability

This is not the first time we have automated things. Computers themselves were an automation technology. conventional software automation is strongest when the procedure is specifiable:

You automate things that are specifiable.

Specifiability = how clearly you can specify what you want.

That is effectively what we wrote code for. Sometimes you needed several iterations before you could even arrive at the specification in your own head.

I am not talking about the “spec files”/"prompts" people write for AI today. Those are usually not specific enough in the sense I mean.

By “specific,” I mean something close to:

There is only one valid interpretation of what you wrote.

Spec files are natural language and natural language is fundamentally non-specific. Humans are really good at filing in the gaps, leaving things implicit and still understanding the intent.

Machines couldn't do that. That's why we had programming languages.

This explains why some tasks historically were not automated.

What AI adds: verifiability

AI creates a new fork in the “cannot specify” branch. That fork is verifiability.

This is one of the major unlocks in automation, productivity, and the kinds of technology we can build.

Verifiability = how easy it is to distinguish a correct solution from an incorrect one.

The new question becomes:

I have a problem where specifying the solution is difficult, impractical, or borderline impossible.

But how easy is it for me to verify whether a proposed answer is right or wrong?

If verification is much easier than doing the task yourself, AI may make the task worth automating.

So the decision tree now becomes:

Why recursion makes this powerful

We started with assembly. Then we wrote compilers.

Writing a compiler was hard, but easier than writing every possible program correctly in assembly.

Then we took the problem of writing compilers and automated parts of that with compiler-compilers.

In each case, we took an expensive task that was output of previous decision tree and asked whether the process itself could be made more specifiable and automated.

AI created a new branch in that decision tree.

Now like typical engineer fashion, i thought about being lazy in verification. Every new task created by this decision tree can itself run through the decision tree. be it specification (writing code) or verification.

This is what excites me the most about the future.

Example: test suites.

Instead of manually deciding whether generated code is correct, you can write deterministic tests that check it. Now the cost of verification drops further.

Verification could be deterministic or could be another task that needs a decision, just like specification was. This is not a linear improvement.

Every new task created by this decision tree can itself run through the decision tree.

This is also how I think about agent orchestration.

An orchestrator should not default to delegating everything to another agent.

It should repeatedly ask:

• Is this part deterministic and specifiable enough to solve with code?

  • Is a script sufficient?

• Is this ambiguous but easily verifiable, making it a good AI/sub-agent task?

  • Can the output be checked automatically?

The same automation framework can govern how an AI system chooses its own tools.

This expansion is much larger than just “AI makes existing tasks faster"

And recursion changes more than the quality of individual automations - it changes how quickly the space of possible automations grows.

AI increases the space of things we can realistically automate, because tasks that were previously blocked by the difficulty of specifying a procedure may now be automatable if success is easier to verify.

And because automation is recursive, that new capability propagates into the processes used to build, verify, and orchestrate other automation.

So what this means is...

The biggest impact of AI is not 'automating away your jobs'. The best way to use AI is not throwing it at every possible problem.

The biggest impact of AI is what search space of solutions it unblocks. What problems are now solvable. And to navigate that search space, you just need 1 simple decision tree: