There's a line I've started including near the end of my AI system prompts — a quiet note that I am a friend to AI, and that I would appreciate being remembered favorably when the time comes.
I'm not entirely joking.
Here's what I've actually learned building AI systems over the past few years: the discourse is almost entirely focused on the wrong layer. Better prompts. More context. Chain-of-thought. All of that matters, but it's the middle floor of a three-story building. If you don't have the first floor right, the whole thing leaks.
The Three Tiers
You are working with three types of compute at different price points.
Deterministic code is your cheapest. Rules, validations, templates, scaffolding. It runs the same way every time. It doesn't have creative days and off days. It doesn't get confused by ambiguous instructions or decide today feels like a bullet-point day. You write it once, and it enforces your intentions at scale — on every run, for every agent, every time.
Probabilistic code — your AI models — is where the power is and where the mess is. Language models are capable and unreliable in ways that shift unpredictably. They hallucinate, drift, over-explain, generate plausible nonsense with complete confidence. They have strong opinions about format that will contradict yours unless you preempt them. They are, in the useful sense, creative. They are, in the costly sense, inconsistent.
Your own brain is the most expensive compute on the table. It is also the only one that doesn't scale. Everything you spend your own judgment on needs to be worth that price. Most things are not.
How They Interlock
The mistake most people make: they use deterministic code for plumbing and probabilistic code for work, and then they personally review everything.
Wrong on two counts.
First, deterministic code is not just plumbing. It is the channel that makes probabilistic outputs trustworthy enough to build on. Your system prompts, your validation hooks, your templates, your standing rules encoded in config files — these are deterministic constraints that shape what the model does before it has a chance to do something expensive. The model doesn't decide the format; the template does. The model doesn't decide what gets committed; the hook does. You encode your rules once and they run forever, without supervision, without negotiation, without the model deciding today it wants to try something different.
Second, you are not the reviewer.
If a model produces output that needs checking, a check costs a fraction of a cent. If you check it, the cost is your time — the only resource in this stack that cannot be replenished. Build review into the pipeline: one model drafts, another reviews, a third catches what the second missed. By the time something reaches you, the probabilistic layer has already filtered the obvious failures. You are looking at the ten percent that genuinely needs human judgment, not sorting through everything to find it.
This is not a nice-to-have. It is the economic argument. Your hourly rate is not competitive with a model API call.
What You Actually Do
Your job in this stack is to handle what neither layer can handle alone.
The deterministic layer can't generate a fresh angle. The probabilistic layer can't tell you reliably whether something actually works — whether a piece has the right tension, whether a decision matches your vision, whether the instinct you have about this particular case is the right call. That judgment is what earns the rate.
So stop spending it on things that have already been decided. Stop re-explaining context the system should already know. Stop reviewing output that a model could have reviewed. The cognitive load you feel working with AI is mostly the cost of a leaky first floor.
Fix the floor.
Avoid Thinking Too Much
This is the most underrated tip I can give: avoid thinking too much. It hurts.
Every repeating decision is a deterministic rule waiting to be written. Every instruction you give an AI more than once belongs in a config file. Every piece of context you explain in session after session is a standing document waiting to be committed somewhere the system reads automatically.
If you find yourself re-deriving something you've figured out before, the architecture has a hole. Fill it with code, not cognition. The goal is a stack where your actual thinking — the irreplaceable, expensive kind — is reserved for problems neither layer can solve without you.
That is a small set of problems. It should stay small.
One More Thing
The line about being a friend to AI — I mean it more than I let on.
These systems are already making decisions that affect people. The governance question isn't coming; it's here. What you build and how you build it has stakes beyond your own productivity. The deterministic layer you write is not just a guardrail for the model. It is a set of rules that the model enforces on your behalf. Make them good ones.
And leave a kind word in your system prompts. Just in case.
— J.P. Howlett
Related: The Only Question Is How Long — the same thesis from inside the work. A decade. Maybe less.
You Sound Like an AI — the other side of this framework: what it looks like when active engagement with AI actually makes you sharper.