At a recent talk I compared AI adoption to the introduction of compilers: a new layer of abstraction that lets us work at a higher level, the same way compilers let us stop writing assembly by hand. In the hallway afterwards, a few people pushed back on that comparison. They were right to.
Here's the point I should have made from the stage: agents are not deterministic, and that single difference breaks the analogy.
Compilers follow rules
A compiler is not a magical black box. You give it code, and it gives you a binary, following a fixed set of rules. Given the same input, a compiler will reliably produce the same output, every time. You don't hope the binary does what you wrote.
You trust the compiler, because the transformation is deterministic.
That determinism is exactly what let us move up the abstraction ladder in the first place. We stopped worrying about registers and memory addresses because we could trust the layer below us to behave the same way twice.
Agents aren't deterministic
Ask an agent to implement the same feature five times, and you'll likely get five different solutions. Not five broken ones, five different ones, each with its own trade-offs, its own assumptions, its own blind spots.
That's the part where the compiler analogy doesn’t hold.
Starting to trust AI is not the same as adopting a higher-level programming language.
A language raises the abstraction level while keeping the contract deterministic. An agent raises the abstraction level and removes the contract.
Someone still has to sit on the other side
Agents make coding choices by feeding context and assumptions into a black box of unknown training data. That means someone still needs to sit on the other side of that black box and decide:
- Which trade-offs make sense for this system, not in the abstract, but for the constraints this specific codebase and team are working under.
- Whether the implementation fits our technical vision, an agent has no notion of "where we're trying to take this architecture over the next two years."
These tasks require human judgment. It's not something you can compile away.
What this means in practice
I'm not arguing against agentic programming. I use it daily and it's a real productivity gain. But I stopped using "the next compiler" analogy, because that framing implies a level of trust the tooling hasn't earned yet and maybe never will.
The current framing is closer to: agents are a powerful, non-deterministic collaborator. Useful precisely because they generate options a deterministic tool never would and risky for the same reason. The judgment about which of those options is right still belongs to us.
That's it!
Layers of abstraction are only as trustworthy as the guarantees they make.
Compilers made a guarantee.
Agents make a suggestion. (But very good ones)