TL;DR

Big AI labs want you to automate your business by funneling every piece of information (i.e., “tokens”) through AI agents, but you shouldn’t.

What you should do is automate mostly with deterministic code written by AI agents.

Here’s the take:

How we got here?

Knowledge work is basically information processing.

Before we had computers, information was processed (i.e., transformed into different information) only inside human brains.

Then computers happened, and much of the software industry is the story of moving information processing from human brains to computer code. That was wonderful, because code execution is not only much cheaper and faster (like 100,000 times cheaper and faster than human brains), but it’s deterministic — hence much more reliable than human brains.

And because code is hard to learn, and slow to produce, we created user interfaces that make it easy and fast to use computers to process our information.

That has been great. Computers get things done better, cheaper, and faster.

AI for knowledge work

Then came along AI (a.k.a. “machine learning”) and gave us a way to create “processors” (a.k.a “models”) for tasks that we didn’t know how to solve with code. Instead of codifying a process, we feed models examples, and they “learn” how to process the next piece of information they receive. This works exceptionally well.

The pinnacle of these models is, of course, the amazing creatures called “LLMs”. The reason they are so useful is they are general information processors, much like human brains.

This amazing fact makes it obvious they will play a major part in knowledge work.

“Big AI” wants all your tokens

Today, the narrative for “how AI changes knowledge work” is that you should send all the information (i.e., “tokens”) to agents to work like people.

The incentives are clear:

1. There is an oligopoly of companies that hold the best AI models
2. Your tokens are their profit
3. Your tokens are data for their next models

So they have many billions of $$ to sell this story.

But that’s misguided.

Maximize Code, Minimize AI

While it’s mind-boggling that AI agents can do knowledge tasks like humans, it has blindsided us to the more incredible fact: AI can automate those tasks with code extremely well.

Instead of asking an agent to do the same task over and over like a human, ask it to write the script that does the task automatically and deterministically.

Why?

“Information processors” (brains, code, and AI) can be measured across three dimensions: Reliability, Cost, and Flexibility.

Code wins two out of the three.

So the funnel should be:

1. Whatever can be done in code - should.
2. What can’t, should be attempted with AI (as little as possible).
3. The rest should be done by humans.

Example - Email Forwarding

Email forwarding might be the simplest form of automation. Let’s say that every time we get an email from “Acme Inc.” with “receipt” in the title, we should forward it to Bob from accounting.

An “AI Maximalist” approach would be: create a “triage agent” that receives every email, has all the email tools to do the work, and a big instruction file (like a SKILL.md) that says which email should go where.

That’s a bad solution to a simple problem.

You would be paying a lot for email management in AI fees, and you would also get a much less reliable solution that presents major risks. The agent could forward to the wrong person (because it got confused with different instructions), and an attacker could send a malicious email and inject a prompt to get the agent to forward sensitive emails from your inbox back to them.

A “good old” code-only automation is faster, cheaper, and much more consistent and secure.

“But what if I need AI to classify, or write the email?”

Then have the AI do that part, and only that part. Have the code use LLM calls to classify the email.

“And what if I need the AI to use some tools to make this work?”

Then have an “agentic step” for that specific part, with only the specific tools and scope that are required, for that specific purpose.

Do as much as possible in code.

Code is hard — AI can help

There are reasons code still has not automated many things it could have by now.

Code is expensive to produce, hard to understand, and it’s not flexible enough for a lot of tasks.

But AI can help with all of that.

AI can help produce and understand code very fast (even for non-programmers).

And code can use AI (yeah, not the other way around) to solve the fuzzy parts that need a more flexible “information processor”.

Company as a Codebase

The way to transform the workplace with AI is not to mold AI to “people-like” entities that do work like humans do and it’s not by generating more apps for people to learn and operate.

The right way is to accelerate and democratize scripting, through AI coding agents. Continuing the long arc of moving information processing into code.

It will be a company-wide effort to build the company as a codebase that runs autonomously, leaving people to architect it and make the important calls.