Promise kept: this is the piece Everyone Is Asking the Wrong Question About AI closed by promising. Here it is.

How many times has your gut been right?

Not the times you wish you had listened — the times you actually had the feeling, and later found out whether it was correct.

I have been asking people this for years. Strangers, colleagues, people at dinners. The answer comes back remarkably consistently: north of ninety per cent. And not from one or two people. From something like nine out of ten of everyone I ask.

That is a strange number to just walk past. Ninety per cent is not a hunch. If a model gave me ninety per cent on a hard classification task, I would ship it.

So either a lot of people are flattering themselves about their own track record, or something real is happening and we have a bad name for it. This piece is about what that thing actually is, and about a rule that follows directly from it, one short enough to keep in your head:

Never delegate judgment.

The three ways of working with AI, and the one that has no name

That number — the ninety per cent — is what you are risking every time you take a model’s answer without running it through your own filter first. So before going further into what the filter actually is, it is worth being precise about how people are skipping it.

Ethan Mollick describes two well-known modes in Co-Intelligence. The centaur divides the labour on a clean line: you do this part, the machine does that part. The cyborg intertwines — you move back and forth continuously, sentence by sentence, until the seam between your work and the model’s is hard to find.

Both are real. Both work. I have watched excellent people operate in each.

There is a third mode, and it has no name, so I will give it one.

Abdication. Not dividing the work. Not intertwining with it. Handing it over and looking away. The centaur and the cyborg both get a noun. This one gets the ghost — present in name, absent in substance.

Why it feels like winning

Abdication does not feel like a failure mode. That is the whole problem.

It feels like leverage. It looks identical to being fast. The output arrives, the ticket closes, the deck goes out, and nothing in the moment tells you which of the three modes you were in. There is no error message for having stopped thinking.

And it compounds in the wrong direction. Every time you accept an answer without checking it, the cost of checking the next one goes up, because you have less context than you would have had. The gap between what you have shipped and what you understand widens quietly, and it widens fastest in exactly the people who adopted AI earliest and hardest.

Then one day the model is down, or rate-limited, or confidently wrong in a way that matters, and you discover the thing that was actually true the whole time: they did not get faster.

They got hollow.

The distinction that actually matters

The usual debate is about volume. How much AI should you use? Should juniors use less? Is it making us worse?

Volume is the wrong axis. I know people who use AI for almost everything and are getting sharper, and people who use it lightly and are getting duller. The dial is not the variable.

The variable is which part you hand over.

Delegate the search. Delegate the boilerplate. Delegate the first ten wrong answers — that is the best possible use of a machine that does not get tired or embarrassed. Delegate the tedium, the formatting, the scaffolding, the lookup you have done four hundred times.

Keep the deciding. What to build. Which tradeoff you are accepting and what it costs. What “done” means. Why this design and not the other one. Whether the thing in front of you is actually right, or merely fluent.

That is the whole rule: never delegate judgment. What it does not tell you yet is why your gut gets to ninety per cent in the first place, or what “judgment” is actually made of. That is worth answering properly, because the answer is what makes the rule more than a preference.

But what IS judgment, actually?

I have been using the word as if it were obvious. It is not, and unpacking it is the reason the number at the top of this piece is real and not self-flattery.

I am not a neuroscientist. What follows is a plausible story assembled from what I know, mostly from building machines rather than studying brains.

Start with the problem your body actually has

Right now your senses are producing an enormous volume of data. Photons, air pressure, skin temperature at every point, joint positions, chemical traces in the air.

If all of it reached your awareness you would not be overwhelmed. You would be useless. You could not hold a thought long enough to finish it.

So there is a filter, and you can catch it working. You were not aware of your shirt against your shoulders until you read that. Or the hum of the room. Or the floor against your feet. All of it was sensed. Almost none of it was reported.

Your awareness is not receiving the world. It is receiving a heavily edited summary, and something else chose the cuts. The interesting question is what happened to everything that got cut.

The architecture, in the only vocabulary I actually speak

A metaphor, not anatomy — but one that keeps predicting things correctly, which usually means there is something under it.

The amygdala is a tiny dedicated chip. One small network, very few outputs — fight, flight, freeze, and by some accounts a fourth, appease. It is the fastest thing you have because it is the smallest and does almost nothing. It does not deliberate. It fires.

The cortex is the CPU with the memory attached — short-term, long-term, and enough processing to run the filter above. It decides what is worth escalating.

The executive brain is the GPU. Massively parallel, the part we proudly call thinking. Fast, expensive, and — critically — it only ever sees what the filter passed it.

And then there is the gut. It has its own nervous system: the enteric nervous system, between one hundred and six hundred million neurons, enough to run digestion without asking your head. That is why “second brain” stuck.

But the number that stops me is not the neurons. Picture every blade of grass in a football field — roughly forty million. Now picture a million football fields. That is the order of magnitude of the microbial population in your gut: tens of trillions of organisms, chemically active, in constant conversation with your nervous and immune systems.

In machine terms: enormous memory, enormous parallelism, a very slow clock. Not a processor for arithmetic. Exactly the processor for holding a vast, slowly-updated model of what normal feels like.

The jungle

You are walking somewhere wild and you become certain — not suspicious, certain — that something is behind you. Your neck knows before you turn. Ask what evidence you had and you would say I just know.

But consider what was available in the seconds before. The birds stopped. A different set moved, all one direction. A troop of monkeys that was ignoring you has gone quiet and is looking past you. Insect noise dropped out of one quadrant. There is a smell that was not there ninety seconds ago.

Every one of those reached you. Your eyes and ears and nose captured all of it. It simply did not clear the filter, because individually not one of them is worth interrupting you for.

Collectively they are one pattern, the pattern has a name, and something matched it against a very old library and returned a single bit: wrong.

That is what a gut feeling is. Not the absence of reasoning — reasoning you did not get the transcript of. The conclusion cleared the filter; the evidence did not. Which is exactly why it arrives as a feeling instead of an argument, and why you cannot defend it when challenged. You never had access to the inputs.

None of that pattern-matching happens in the gut itself. The enteric nervous system does not think, feel, or generate conscious thought — it runs your digestive tract with remarkable autonomy, not bird-watching. What is actually doing the computing sits one level up: Antonio Damasio’s somatic marker hypothesis, which holds that bodily states guide decision-making nonconsciously. Your body registers a response before your conscious mind produces a reason, and that response biases the choice you are about to make.

The usual evidence is the Iowa Gambling Task. Participants draw from four decks; two are quietly rigged to lose. Healthy participants start avoiding the bad decks before they can tell you which decks are bad. The body’s response comes first; the explanation later, if at all. Patients with damage to the ventromedial prefrontal cortex — the region that integrates those bodily signals — keep choosing the losing decks, reasoning fine and losing anyway.

The processing happens in the brain, below awareness. The gut is part of the loop and part of how the result is delivered — more the display than the processor. There is a documented mechanism by which you know things you cannot justify, and it outperforms the part of you that talks.

The oldest version of a method for this is 2,400 years old

None of the above is new, and going back to where it is oldest is what turned it from an observation into something you can actually practice.

Socrates did not write. What we have is mostly Plato, and in the dialogue Theaetetus Socrates explains what he thinks he is actually doing when he talks to people. His mother, Phaenarete, was a midwife. He says he practises the same trade — on minds.

The word for it is maieutics, from the Greek maia, midwife.

And then he adds the part that changes the image completely: he is barren of wisdom himself. He has nothing to deliver. He can only help you deliver, and then help you work out whether what was born is healthy or not worth raising.

That is a much stranger claim than “asking questions is a good teaching technique.” He is saying the knowledge was never his to give. The dialogue is not a transfer. It is a birth, and it happens in you.

The two moments when the idea gets born

Read enough of the dialogues and you notice the birth almost never happens while someone is being told something. It happens at one of two moments, and the Greeks had a word for each — and once you have the neuroscience above, you can see exactly what each word is describing.

The first is when you contradict yourself. Socrates’ method of cross-examination is called elenchus, and its defining feature is that he refutes you using only premises you yourself just conceded. He does not import an outside argument. He shows you that two things you already believe cannot both be true. Nobody defeated you. You were already holding both — one compiled, one not, and they disagreed.

The second is when you run out of road. The state that elenchus produces is called aporia — from a-poros, literally without passage, no way through. It is the moment you reach the edge of what you actually know, as opposed to the edge of what you can fluently say.

Aporia feels like failure. Socrates treats it as the opposite: someone who knows they do not understand something is in a far better position than someone who falsely believes they do. Those two moments — self-contradiction, and the boundary of your own knowledge — are the only two places new understanding reliably comes from. Everything else is transfer, and transfer does not change what you can do.

Now look at how you actually use AI

Here is the uncomfortable comparison, and it is why this 2,400-year-old method is suddenly relevant again.

Socrates was barren of wisdom and full of questions. A language model is the exact inverse: full of answers, and it has lived nothing. It has read more than any human ever will and been in no rooms at all.

And the default interaction we have all settled into runs in the wrong direction. You bring a question. It brings an answer. You accept the answer. That is abdication compressed into a single exchange, and the tooling nudges you toward it a hundred times a day. Nobody decided this. It is just what a chat box implies.

Co-dialectic is the inversion. Not “give me the answer” — cross-examine me until I contradict myself or run out of road. Make the machine play Socrates, which is the one role its architecture is strangely well suited to, because a system with no lived experience has no ego invested in your being wrong.

The reason this matters for the rule at the top of this piece: elenchus is judgment training. It is the mechanism by which you get calibrated. Abdication skips it. Co-dialectic is how you keep the loop that abdication quietly removes.

How to actually implement it, today, in whatever you already use

You do not need a plugin for this part. You need to change what the model thinks the relationship is, and you need it to persist so you are not re-establishing it every session.

Step one: write the premise into your global config, not into a chat message.

Every serious tool has a persistent instruction layer — a global memory or config file, a custom instructions field, a system prompt. That is where this belongs. A framing you retype each morning is a framing you will stop retyping by Thursday.

Step two: state the division of labour and, more importantly, the division of ownership.

Most people write “be my thinking partner,” which is a vibe, not an instruction. Be specific about four things: what you bring, what it brings, what you decide, and what it decides.

Something close to this, in your own words:

We work as one unit that produces one output together. Neither of us is the assistant.

I bring judgment, taste, and the things I learned by being there. I have been in rooms you have not been in, and I know things I cannot fully put into words. You bring recall across far more material than I can hold at once, speed, and the ability to see a pattern across all of it. You have read more than I ever will and lived none of it.

I own the decisions: what we build, which tradeoff we accept, what “done” means, and whether an answer is actually right. You own the search, the drafts, the first ten wrong answers, and the tedium.

When I ask you something that is really a judgment call, do not answer it. Ask me the question that shows me where my own position breaks. If two things I have told you cannot both be true, name those two and stop. If I have gone past what I actually know, say so plainly instead of filling the gap fluently.

Never flatter me. Do not open by telling me it is a good question. Flattery lowers my filter, and the filter is the reason I am here.

When you disagree with me, say it once, plainly, with the reason. If I overrule you, drop it and do not relitigate it through what you build next.

Step three: notice which instruction you want to delete first.

For most people it is the no-flattery line, and that is worth sitting with. Praise is pleasant and it is also the mechanism by which the conversation stops being useful. A model that opens by admiring your question is managing you, not thinking with you. It also quietly teaches you to bring it questions you already know the answer to.

Step four: use aporia as the success metric.

You are not looking for a session that ends in a good answer. You are looking for the moment the model asks something you cannot answer, or points at two of your own statements that do not fit. That is the birth. That is the entire point of the exercise, and it is the only output that stays with you after you close the laptop.

If you never hit that moment, you were not in a dialectic. You were being served.

That compressed premise is a public version of the first idea in something larger — the constitution that Exponential OS runs on, which governs harder problems: how a swarm of agents shares memory across sessions, when an agent may act without asking, and how a lesson learned by one becomes available to all of them. None of that is required to use what is above. The premise is the load-bearing part, and the premise fits in a config file.

What this looks like in a system, not just a chat

The same principle scales down into architecture, and this is what I actually build. I have argued a version of this before, from a stage: in January 2026 I gave a keynote on behavioural-health systems, and the line I closed with was “automation doesn’t remove risk — it redistributes it.” Remove human judgment from a loop and you do not eliminate harm, you obscure accountability and shift the burden onto the most vulnerable person in the system. I was arguing it in the highest-stakes domain I could find, months before it became a general conversation about AI — because the principle was never really about AI. It was about where judgment is allowed to live.

Here is what that principle looks like when the system is software instead of a hospital:

Verification is a funded stage, not an intention. The bottleneck in agentic systems is not generation, it is verification. “I will look it over” is not a stage.

A model reviewing its own output shares its own blind spots. So review runs cross-family — a different model, from a different lab, trained on a different mixture. Two instances of the same model agreeing tells you almost nothing. That is elenchus with the ego removed.

Disagreement is the signal. When judges disagree, that escalates rather than getting averaged into a pass. Averaging is how you destroy the only interesting datapoint you had.

Evaluations run as deploy gates, not dashboards. A correctness regression blocks the release. A dashboard that goes red and ships anyway is decoration.

Acceptance criteria are fixed before the code exists. Otherwise “done” drifts toward whatever was produced — the most human failure mode in the stack, and it has nothing to do with AI.

None of it assumes the model will be right. All of it assumes the model will be confidently wrong and the system has to be right anyway.

Which is why judgment is the part you cannot hand over

A large part of judgment is not reasoning at all. It is the accumulated, unindexed residue of everything you have been present for. The meeting that felt wrong for reasons you could not name and was exactly as wrong as it felt. The hire everyone loved on paper. The architecture that looked fine and made your neck itch.

You cannot write that down — which is precisely why you cannot delegate it. A model can be given everything you know how to say. It cannot be given what you know and cannot say. And the second category is where the ninety per cent lives.

That asymmetry is not a temporary gap that scale closes. It is structural. The machine has read everything and been present for nothing.

How far the machine actually is, on the axis nobody measures

Some numbers, checked rather than remembered.

Your brain is about two per cent of your body mass and consumes about twenty per cent of your energy — a tenfold concentration. In power terms, on the order of twenty watts. A dim bulb.

What that twenty watts computes is genuinely hard to state; serious estimates span orders of magnitude depending on how you define an operation. The headline comparison is commonly put at exaflop scale.

Now the other side. As of 2026, El Capitan reaches about 1.8 exaFLOPS. It has genuinely caught up on raw speed. It draws roughly thirty megawatts.

Twenty watts against thirty megawatts. Call it a million to one.

And that flatters the machine, because it compares speed to speed. It does not count what your twenty watts is also doing: running the sensory filter, maintaining a body, holding a lifetime of context, and producing the ninety-per-cent signal we started with.

And we have not digitised two of the five senses

This is the part that surprises people, and the one I would point at hardest.

Taste is essentially undigitised. Not poorly digitised — there is no taste equivalent of a camera or a microphone. Nothing captures a flavour, transmits it, and reproduces it elsewhere.

Smell is barely started. We have detectors for specific molecules — smoke, carbon monoxide, particular volatiles — which is a smoke alarm, not a nose. A nose separates an enormous space of compounds and mixtures, in context, at trace concentrations, and wires them straight to memory in a way no other sense does.

Two of your five input channels have not meaningfully been captured at all. Before worrying about a machine replacing your judgment, notice that it cannot yet replace your tongue. The sensor package is not close — and judgment is built out of what the sensors gathered over a lifetime.

So what is the actual future

Not replacement. That story needs the machine to acquire what it has no route to: presence, a body, twenty watts, and forty trillion collaborators in your abdomen.

And not romanticism either. Human intuition is ninety per cent, not one hundred, and the missing ten contains some spectacular errors. That is exactly why you pair it with something that has read everything.

The interesting configuration is the one where each side brings what the other structurally cannot. You bring judgment, presence, taste, and the unindexed library. The machine brings recall across more material than you can hold, speed, and pattern-matching across all of it — having read everything and lived none of it. Neither is the assistant. Both sign the output. I have a naive name for what that combination aims at — ASHI, Artificial Super Human Intelligence — not AI that replaces the human, and not a human with a faster tool, but the two as one unit, deliberately assembled, each covering the other’s structural blind spot.

And that is the real reason never to delegate judgment. It is not sentimentality about being human. It is that judgment is the part you are actually contributing. Hand it over and there is no cyborg. There is just the ghost — a slower copy of the machine, signing work it never did.

The uncomfortable part

Keeping judgment is slower this quarter. Genuinely, measurably slower.

The ghost will out-ship you for a while. In a demo they will look better. In a sprint review they will look much better.

I do not have a comfortable answer to that, and I distrust people who offer one. What I have is a longer horizon: the ghost’s advantage lasts exactly as long as nothing surprising happens, and something surprising always happens. When it does, the difference between the two of you is not speed. It is whether you can do the job at all.

A test you can run today

Take the last significant thing you shipped with AI.

Can you explain, to a colleague who is annoyed about it, why it is the way it is? Not what it does — why that tradeoff, why that structure, why not the obvious alternative?

If yes, you were a centaur or a cyborg. Either is fine.

If you find yourself reaching for the model to reconstruct your own reasoning, you already know which mode you were in.

That is not a reason to use less AI. It is a reason to move the line.

Sharpen the input side first

If a gut feeling is pattern-matching over sensory data that never cleared the filter, then one thing follows immediately, and it is the most actionable idea in this piece.

The quality of your judgment depends on the quality of what your senses actually took in.

Not on how hard you think. On what got captured before the filter ran. You cannot pattern-match against material you never registered, and modern life is very good at narrowing the aperture — head down, one screen, same room, notifications carrying the only signals you consciously receive all day.

This is what grounding exercises are actually for, and it is why I stopped treating them as a wellness accessory. Deliberately attending to each sense in turn — what you can see right now, hear right now, feel against your skin, smell, taste — is not relaxation. It is re-opening the input channel and feeding the library that the nonconscious matcher draws on.

Treat it that way rather than as a calm-down technique. You are maintaining the sensor array that your ninety per cent runs on. If the machine’s disadvantage is that it has no senses and no presence, then letting your own senses narrow is the one way to voluntarily give up your only structural advantage.

Then point the machine at the other half

Sharpening your input is one side. The second move is what you do with it.

Use your AI as a co-dialectic, not as an oracle. Bring the thing only you have — judgment, lived experience, the ninety per cent you cannot justify — and let the machine bring the half you do not have: recall across more material than you can hold, and the ability to see a pattern across all of it.

And do it for the right job. Not for answers you could have looked up. For synthesis, and for innovation. And ask for the right thing. Most people ask a model to produce. The two asks that actually exploit the asymmetry are:

Poke holes in this.

Strengthen this using what you know that I do not.

Both of those point the machine at the half you cannot cover, and they are worth being precise about why they work.

It pattern-matches across a volume you cannot approach. Not marginally better — trillions of comparisons against material you will never read. Ask it where your argument has been made before, where it failed before, and what the strongest published objection to it is, and you get in seconds what a literature review would cost you weeks.

It does not get tired and it is not on a clock. It has no bad afternoon, no ego about being wrong, no investment in the position it argued five minutes ago. That is what makes it a better Socrates than most humans — elenchus is unpleasant to receive from someone who enjoys it, and the machine does not enjoy it.

And on the other side, be equally clear about what only you have. You are time-bound — for now, that is the human condition and it is the constraint AI has not solved. You have lived experience. You have the compiled judgment described above. Nobody can give you more hours, and nobody can give the machine a life.

That is the work neither side can do alone, and it is worth being precise about why. Synthesis needs both a wide field of material and a sense of which connection actually matters — the machine has the field, you have the sense. Innovation needs both a large space of possibilities and the taste to know which one is worth building — the machine can generate the space faster than you ever will, and it has no way to know which corner of it is interesting, because interesting is a judgment and judgment is what you brought.

Ask it for an answer and you get a lookup. Bring it your half and ask it to argue with you, and you get something neither of you walked in with.

That is the whole trade. Sharpen your senses so your side is worth bringing. Then bring it, and never hand it over.

Delegate the search, the draft, the first ten wrong answers, the tedium. Keep the deciding.

Socrates could not give anyone knowledge and said so. The machine on your desk can hand you an answer for everything and has lived through nothing. Only one of you in that conversation has been in the room. Act like it.

This is the follow-up I promised in Everyone Is Asking the Wrong Question About AI, which lays out the seven habits of the AI world. Habit one is learning how to learn. This is the one that protects it.

Which brings me to what’s queued next, because both pieces came directly out of writing this one.

The neuroscience above says gut and wisdom survive because they are structural, not sentimental. I went looking for whether that holds up from the outside too, and found it backed from an unexpected direction: Anthropic’s own economic modeling of what AI does to the economy, three scenarios, modest to extreme, a twenty-fold spread between them — and judgment is the one thing that wins in all three. Then I went looking for where I think that model is wrong, and ended up at an Athenian army in 490 BC that had no business winning the battle it won by a mile.

The other piece: two hundred books in two years, after reading nothing at all for the twenty years before that. Not a discipline story — a framework story, and the three sentences of Greek philosophy that turned out to already be sitting underneath how I was thinking, twenty-three centuries before anyone called it cognitive therapy.

That is two pieces queued. If you want one sooner, say which in the comments — I order them by what people actually ask for, and one line from you moves it up.

If this was useful, three small things that actually help it travel: hit like so it reaches someone who needs it, tell me in the comments whether your own gut number landed north or south of ninety per cent, and send it to the one person you thought of while reading.

That should stop you, and it is worth sitting with before you read another word.

Two days ago Dario Amodei published an essay called “We Must Pace the Frontier”, arguing the industry should deliberately slow how fast models gain capability. Within hours Sam Altman committed to match the first step. Elon Musk wrote three words: “Dario is right.” The market discounted AI-exposed valuations.

They said it anyway.

Costly signals are the only kind worth reading

I teach a version of this to executives at Berkeley and it applies cleanly here. When someone tells you something that costs them nothing, you have learned about their marketing. When someone tells you something that costs them money, you have learned about their beliefs.

These men run the labs. Their valuations are built on the assumption that capability keeps compounding on schedule. Arguing publicly for a slower frontier is an argument against their own quarter, and the market charged them for it inside the same week.

That is a costly signal. It does not prove they are right. It does prove they mean it.

Now notice who is not asking.

Not the regulators. The President spent the week emphasizing America’s lead over China. Not the legislatures. Not any government with subpoena power or inspectors. The alarm is coming from inside the building, and the building holds the only instruments.

That asymmetry is the entire story. The people with the measurements are frightened. The people with the authority are not. When the only parties who can see the dial are the only parties asking to slow down, the reasonable inference is not that they have gone soft. It is that they are reading something the rest of us cannot see.

So what are they reading?

They have told us, publicly and in unusual unison. Amodei, Hassabis and Altman jointly called for laws against AI-assisted bioweapons, warning that these systems now outperform PhD-level virologists on many biotechnology questions. Ask people in this industry what actually keeps them up and the answers converge with unsettling consistency on one scenario: a pathogen, engineered, moving too quietly and too fast to contain.

Anthropic then published what it had actually caught.

Roughly thirty-five separate efforts in a single thirty-day window, attempting to route around safety controls. Bird flu. Orthopoxviruses. Novel venom toxins. In one case from May, a researcher affiliated with a military institute asking for help drafting a grant application for gain-of-function work on chikungunya.

And then the line that nobody should skim past:

Their newer models can no longer be assumed to sit below the threshold for meaningful bioweapons assistance.

That is the first time a frontier lab has said that out loud about its own system. Not a think tank. Not a critic. The lab, about its own model, in public.

My question is simple, and I have not found anyone with a satisfying answer to it.

That is what the monitoring caught. What about what it did not?

Thirty-five interventions in thirty days is not a reassuring number. It is a sampling rate. It tells you the detector is working. It tells you nothing about the denominator.

The fiction was optimistic

We have had the parables for two decades and we have learned almost nothing from any of them.

The Animatrix imagined how the handoff happens, and looking at it now it reads as generous. It assumed the machines would want us alive, farmed and dreaming. It never considered that the danger might be engineered by us first, with the machine as a very capable lab assistant. It never considered that a system could hand a motivated human a capability no state actor had granted them.

Optimization needs no malice. It never did. That was the whole point of the paperclip argument and we filed it under science fiction because it arrived wearing a costume.

And Tim Urban asked the question in 2015 that still has no answer. Not what happens in the decade after we reach the threshold. What happens in the sixty seconds after.

Nobody has answered that. Not in eleven years. We have simply gotten better at not being asked.

If you have read this far and someone specific came to mind, a founder, an investor, a legislator, someone who can actually move a policy lever, forward this to them now rather than at the end. That is the only distribution that matters for a piece like this.

Which brings me to my neighbors

There are more than 240 billionaires living in California, holding over two trillion dollars between them, according to work out of Berkeley by Saez and Zucman. Worldwide, more than 3,300, holding north of twenty trillion.

You do not just fund this race. You hold the policy. Not metaphorically. The compute gets built where you finance it, the labs incorporate where your counsel advises, and the bills that would constrain any of it live or die on rooms you are in and I am not.

And California is where this gets decided first. This state writes rules the world copies. It happened with vehicle emissions. It happened with privacy. It will happen here. Act local, and it travels global on its own.

So I want to talk about the insurance you have been buying.

The islands. The bunkers. The compounds with the blast doors and the five-year food stores and the hydroponics. I understand the instinct. I want to point out that it is two doors, and both of them close.

Door one: you seal yourself in and it works. You survive. You spend the remainder of your life inside a structure with no community to belong to, no one to build with, nothing to be useful for. That is not survival in any sense a human being would recognize. It is exile, at a premium, chosen in advance.

Door two: you step outside. And the bird carrying the new flu lands on your roof, because a pathogen does not respect a property line and air does not check the guest list.

A blast door filters a mob. It does not filter an aerosol. The threat these men are describing is the one category of risk your money cannot build a wall against, because the wall has to let you breathe.

You are not above this. You are inside it, with better furniture.

The button

We are currently debating whether there should be an off switch. What it would look like, who would hold it, whether it is even coherent to imagine one given China and open weights and the fact that nobody can unilaterally stop anything.

Those are real objections and I do not have a clean answer to them. I am a practitioner, not a policy expert, and I would rather say that plainly than pretend otherwise.

But I know this much. The debate about whether the button exists is only worth having while it still does.

Use the stop button, the one we still think exists, before it disappears.

Anand Vallamsetla writes about responsible AI, agentic systems, and what it takes to keep building with these tools honestly. Previously engineering leadership at Google, Entrepreneur in Residence at AI Fund, and four and a half years teaching AI strategy and responsible deployment to Fortune 500 executives at UC Berkeley Executive Education.

Everything cited here, in one place:

• Dario Amodei, “We Must Pace the Frontier”

• Anthropic, “Countering misuse of AI: September 2026” (the threat report)

• AI executives’ joint warning on bioweapons (Semafor) and the private fear behind it (Axios)

• The market reaction to the slowdown call (CNN)

• Saez & Zucman, California Billionaires (UC Berkeley) and the Forbes 2026 Billionaires List

• Tim Urban, “The AI Revolution: The Road to Superintelligence” (Wait But Why, 2015)

• The Animatrix and the paperclip argument, for anyone who has not met them

A follow-up to the 18¢ piece. That one measured the cost bar. This one measures the latency bar. The goal — precision — never moves.

I was at a dinner for AI leaders at a large bank this week. I asked one of the engineering VPs the question I always ask: what is actually in the way? Not the roadmap — what stops the thing from shipping.

She answered immediately, without having to think about it. Cost against latency.

I asked what models they run. She declined, which is the right answer to that question from someone she met an hour earlier, and I did not press. But the constraint itself she stated plainly, as the thing her organisation is up against.

That stayed with me, because it is not the argument I made in the 18¢ piece. That one was about where the money goes and had nothing to say about time. I had a gap between what I had published and what someone actually running one of these platforms told me was hard.

So I measured it. Not next quarter — the next day, on the only system where I control every variable.

What I am actually measuring

There is an AI concierge on thewhyman.com. A recruiter or hiring manager lands on the page and asks it questions about me — how large a team have you run, what is your reliability record, where has your judgment failed — and it answers from a knowledge base I maintain.

It is a small system with a serious job, and that combination is why it is a useful proxy:

• Wrong is expensive. If it drops a number or invents one, that is my credibility with someone deciding whether to interview me. There is no "eh, close enough."

• Slow is visible. Nobody waits ten seconds on a personal site. They leave, and I never learn they were there.

• The answers are numbers-heavy — team sizes, portfolio scale, availability figures — which makes precision measurable instead of a matter of taste.

The stack, so you can map it onto yours:

• Serving — Cloudflare Workers AI, streaming responses at the edge.

• Shape — retrieval into a prompt. The same shape as most enterprise RAG.

• Knowledge base — about 15,000 tokens total, of which a typical answer needs a fraction.

• Retrieval — deterministic keyword selection over labelled blocks, not vector search, so I can tell exactly what the model saw for any given answer.

• Volume — low. One site. ⚠️ Nothing here is a scale claim.

⭐ What transfers is not my numbers — it is the method, and the size of the error I found by re-running it. A bank at volume has different absolutes and the same structure: retrieval into a prompt, a quality bar that cannot move, a cost line somebody reviews monthly, and a latency budget a human is sitting inside.

Six models, same knowledge base, same question, five runs each.

It was never a triangle

Cost, latency and precision get drawn as a triangle. Three things in tension, pick two. That framing is in most vendor decks and it is wrong in a way that costs you the decision.

They are not three of a kind. Precision is the goal. Cost and latency are bars.

A bar is a threshold. You clear it or you do not, and clearing it by more buys you nothing — nobody thanks you for 200ms when the SLA was two seconds. Precision does not work that way. It is the thing you are maximising, and there is no point at which more of it stops being worth having.

Everything else is a dial.

That line replaces the triangle, and it tells you what to do when a model disappoints you. In the results below there is a model that cleared both bars comfortably and still lost, and a model that hit the goal and blew a bar. Neither is a tradeoff. One violated a constraint. The other missed the point. You fix those differently, and a triangle cannot tell you which you are looking at.

What the numbers said

Median of five runs per model, after a warm-up call I throw away. Failed responses counted separately, never averaged in.

⭐⭐ The model I had in production was the worst of the four that worked, on all three axes. Most expensive. Slowest. No more accurate. Something in that table is 80% cheaper, 1.4 seconds faster, and drops exactly as many figures.

Nothing about that is a tradeoff. It is an unmeasured default, which is a different and more embarrassing thing.

And the reasoning model did not lose on latency — it never finished. Five of five runs failed against a forty-five-second ceiling. For this workload it cannot clear the bar at any price. It was buying deliberation on a task with almost nothing to deliberate about: pull the right figures out of supplied context and say them plainly.

Three method notes, because each exists where the naive version lied to me:

• Throw away the first call. A cold start recorded 137 seconds and made one model look like the cheapest winner at two samples. It was failing two runs in three.

• Medians, not means. Cost varied 0.7% across five runs; precision swung between 3/4 and 4/4 with nothing changed. Cost is stable enough to publish from few samples. Accuracy is not.

• Count failures separately. A request returning nothing in four tenths of a second is the fastest number in the set. Worse, I was still billed for it. Failure is not the absence of cost. It is cost with no product.

📌 Which points at the thing underneath: I did not benchmark six models. I benchmarked one platform's serving of six models, on one afternoon. That is the honest reason to run your own numbers — public benchmarks answer a different question than the one you have.

The drift nobody named

Here is the part I did not expect, and the one I would put in front of an executive.

Model drift is named, watched and tooled. Everyone knows the shape: the world moves, inputs shift, answers get worse. There are dashboards, alerts, vendors.

Look at what that does to your safeguards. Quality evals pass — output unchanged. SLOs green — nothing got slower. Users content — they cannot tell. Every instrument reports healthy while your cost per unit of work climbs for a quarter.

⭐ And notice who owns each. Model drift is an engineering alarm with a team that knows what to do. Cost drift arrives as a line item that grew without explanation, in a room where nobody has an engineering dashboard. The more senior problem, with the less mature tooling.

I want to be precise about my own case, because the obvious version of this story is not what happened. I did measure when I chose the model. I ran the comparison, picked the winner on evidence, shipped it. The embarrassing part is not that I skipped the work — it is that the answer expired and I did not notice. Two of the models that beat it this week did not exist when I chose.

That is a new failure mode, not dependency drift renamed. In conventional software your dependency graph changes only when you change it, and pinning is a complete defence. Here it is not — because pinning protects correctness, and what decayed was optimality. My pinned model kept working: same accuracy, no errors, nothing in any log. It quietly became the most expensive way to get that result, because correct is absolute and best is relative to a menu somebody else controls.

There is no lockfile for that. No test fails.

Continuous Evaluation

Years ago I gave a talk at SXSW about continuous integration, delivery and innovation — that shipping is not an event you schedule but a capability you maintain. This is the same argument wearing different clothes.

So a one-time bake-off is the wrong shape. It answers which model is best today, and the honest shelf life on that is somewhere between a quarter and a month.

⭐⭐ If you already run continuous evals — and most serious teams do — this is not new infrastructure. Your suite runs on a schedule and gates releases. It almost certainly measures quality alone. Put cost and latency in the harness you already own. Same fixtures, same schedule, same gate. Three columns instead of one.

That small change makes two things visible that were structurally invisible:

• Regressions you ship blind. A prompt change that adds context is a cost increase, and nothing in a quality-only suite flags it. Mine moved 2.5× on identical infrastructure purely from how much context the router loaded.

• Savings nobody is hunting. An 80% reduction does not announce itself. It shows up as a new row in a table you were already generating.

📌 And it inverts the objection. The reflex is that evaluation is overhead. The harness I built to answer a latency complaint is the same harness that found an 80% cost reduction on a system I had already optimised. Evaluation is not the tax you pay for shipping AI. It is the instrument that finds the money.

What I would tell a platform team

1. Precision is the goal; cost and latency are bars. When a model disappoints, first ask which one it failed — you fix those differently.

2. Price per completed answer, not per million tokens. Nobody consumes a million tokens, and a failed request still bills.

3. Put a correctness metric in the comparison. "Figures kept" was invented for this problem and it is the only thing that stopped me shipping a model that answers fast and leaves the numbers out.

4. Warm up, take medians, count failures separately. All three exist because the version without them handed me a confident wrong answer.

5. ⭐ Keep the harness and re-run it. Continuous integration for code, continuous evaluation for models — because the right answer moves without asking your permission.

The 18¢ piece found the cost bar breached by rework, because verification was missing. This one finds the latency bar breached by capability the task never asked for. Same goal, different bar — and neither is safely reclaimed without the same instrument underneath.

One site, one workload, five runs per model. If you have measured this at real scale and got something different, I want to hear it.

Every week someone asks me a version of the same question: what should I learn to get into AI?

For a long time I assumed it was a question from people at the start. It is not.

I get it from students, and I also get it from people twenty years into a career who are very good at something the world is quietly repricing. A principal engineer. A director who has shipped more than most people ever will. They ask it more carefully, and usually later in the conversation, but it is the same question.

Here is why it lands so hard for the second group.

Experience used to be an asset that compounded. Now it can also be an anchor. Twenty years of hard-won judgment in a domain is enormously valuable right up until the moment the ground under the domain moves — and then the same twenty years become the reason it is hard to move with it. Nobody warns you that expertise has a maintenance cost.

So the question is understandable. It is also the wrong one, for everybody asking it, at every level.

It is wrong because whatever you learn will have changed by the time you have learned it. The half-life of a specific skill in this field is now shorter than the time it takes to acquire it. Anyone optimizing for a curriculum is running hard toward a place that has already moved.

The better question is harder and it does not have a syllabus:

How do I succeed in an AI world?

Seven habits, from twenty-six years of getting this right and getting it wrong in roughly equal measure.

1. Learn how to learn. Nothing else compounds.

The winner is not whoever knows the most. It is whoever closes the loop fastest

Learn. Apply. Get evidence. Correct. Repeat.

Most people optimize the first step and neglect the other four. They read more, watch more, save more. But knowledge that never meets evidence does not become skill — it becomes trivia. The loop only pays when it closes.

Here is the part people miss, and it is the part that matters most.

When you shorten your loop, you do not only win faster yourself. You teach the shortened loop to the people who come after you, and they start from your ceiling instead of your floor. Then they shorten it again and hand that forward.

That is not a linear gain. It is logarithmic, and it compounds across generations rather than quarters.

Which is why the highest-leverage thing available to you is not learning a framework. It is getting systematically better at the act of learning itself — and then teaching that.

2. Use an Optimal Knowledge Acquisition Framework, not a reading list.

I taught this at Google as a Googler-to-Googler coach, and the pattern held across everyone I worked with. The people who moved fastest were never the ones who read more. They were the ones who knew what to skip.

A reading list is a queue. A framework is a filter. The filter is worth more, because the constraint was never access to information — it has not been for twenty years. The constraint is attention, and attention spent at the wrong depth is simply gone.

Three things the framework has to do:

Acquire faster. Know when to go three levels deep and when one level is genuinely enough. Most material deserves one.

Retain longer. Retrieval beats review. If you cannot explain it without the document open, you have not learned it. You have visited it.

Implement like there is no tomorrow. Knowledge that never ships decays at the same rate as knowledge you never acquired. The only difference is that you feel better about it.

I call it the Optimal Knowledge Acquisition Framework, and optimal is the operative word — the point is not to acquire more, it is to acquire the right depth at the right cost. It gets its own piece. If you want it sooner rather than later, say so in the comments and I will move it up the queue.

3. Find your ikigai before you optimize your resume.

Also something I taught at Google — though I did not find it myself. Pravir Gupta, a VP and GM at Google Cloud and an unofficial coach of mine, handed me the book.

Four circles: what you love, what you are good at, what the world needs, and what you can be paid for.

The reason this matters is not balance. It is fuel. A career built on only what you are good at and what pays runs on push — a manager, a deadline, a promise about the next level. Push runs out, usually around year seven. Pull does not. Find the thing you would read about on a Saturday and the loop from habit one runs on its own: you learn faster than the person being pushed, because nobody has to make you. That is also what survives the pivots, and this field will make you pivot, more than once, whether or not you planned for it.

Pravir put it better than I can: passion and knowledge are a dangerous combination, and if you have ten out of ten in both in a given area, you are unbeatable. Note the last part. Not ten out of ten in general — in a given area. Knowledge is habit one. Passion is this one. Neither alone is dangerous, and that is the whole reason he gave me the book rather than a reading list.

The order matters. Optimize the resume first and you become very good at being hired for work you do not want. Find the intersection first and the resume becomes a description rather than a performance.

4. Your career is not a line. It is hills.

You have to walk down one hill to climb the next. Every senior person you admire has a valley they do not put on LinkedIn — the role that did not work, the company that folded, the year that looks like a gap.

What is genuinely different now is that you can turn the descent into a wave instead of a drop.

The valley used to be long because relearning was slow. You left a domain, and re-entering a different one at real depth took years. That is no longer true. With an AI that can take you to the working edge of a field in weeks rather than quarters, the trough gets shallower and shorter.

That is the biggest structural advantage available right now, and most people are using it to write emails faster.

5. Collect dots that do not connect yet — then use AI to connect them.

You cannot connect the dots forward. You can only collect more of them, on purpose, and trust the pattern to show up later

But this is where AI earns its place, and it is not the way most people use it.

It has effectively infinite knowledge and no lived experience. You have lived experience and a small fraction of the knowledge.

That asymmetry is not a weakness on either side. It is the raw material. Innovation is the synthesis between the two — between what has been recorded and what has been lived. Neither half produces it alone.

So do not use AI as an oracle that agrees with you. Agreement is worthless; you already had that. Make it a co-dialectic. Bring it the intuition you cannot justify yet. Let it argue back. Argue with it. Ask it to show you the three fields where your half-formed idea already exists under a different name.

The dots you could not connect alone start connecting. Not because the machine is smarter, but because you finally have something to think against.

The inversion: this is the golden hour for experienced people

For twenty-six years, every new technology put me at a disadvantage

A new grad could pick up a new language faster than I could. Always. They had nothing to unlearn and more hours to spend, and I was competing on the one axis where youth genuinely wins. That was true of every wave, and I felt it every time.

That axis just disappeared.

Every language is now a prompt away. The thing I used to lose on is free. And what I am left holding is the one thing that took twenty-six years to accumulate and cannot be downloaded: lived experience, which is another word for judgment.

Knowing which of three working solutions will still be working in two years. Knowing when a demo is hiding a problem rather than solving one. Knowing when to kill something. None of that is in the model, because none of it was ever written down — it was paid for.

So let me say the quiet part plainly. I am more effective now than fifty developers were five years ago. Not because I got smarter. Because the part of the job I was worst at became free, and the part I am best at became the bottleneck.

If you have twenty years, you have not been made obsolete. You have been handed leverage on the exact thing you spent twenty years buying.

And it is the best moment to be a beginner, too

Here is the part that should be uncomfortable for people like me, and I would rather say it than pretend.

Everything I know, I paid for with mistakes. Years of them. What worked, what did not, and why — that was tuition, and the bill came in time.

You can now get a large part of that in one prompt.

They say only fools learn from their own mistakes and the wise learn from others’. That was always good advice and almost impossible to follow, because other people’s mistakes were not accessible to you. Now they are. Every post-mortem, every failed architecture, every hard-won lesson someone bothered to write down is one question away.

That is the exponential advantage, and it is available to the person with zero years.

The only thing standing between you and it is knowing how to ask. Which is a skill, and it is learnable, and it is the single highest-return thing you could learn this month.

I spent something like forty hours reading prompting research to work it out. You do not have to. I productized what I learned as an open-source plugin called Co-Dialectic — it runs on Claude Code and other CLIs, and it teaches the method by making you use it rather than by explaining it. That is the whole design: you learn it by doing it. The write-up is here: https://www.thewhyman.blog/p/co-dialectic-v4-is-live-your-ai-is

Both of these are true at once. The experienced person’s disadvantage just vanished, and the beginner’s biggest cost just collapsed. That is not a threat to either. That is the best moment either of you has had.

6. Aim at the field that does not exist yet.

Yuval Noah Harari has warned that by 2050 a “useless class” might emerge, and that bioengineering combined with AI could separate humanity into a small class of superhumans and a large underclass. He is careful to say might. So am I.

I will go somewhere he does not.

I think that within a hundred years there may be a species that looks back at us the way we look at chimpanzees today. Not a metaphor about capability gaps — an actual discontinuity, where the thing looking back is part biological and part engineered, and the distance is not one of degree.

If that is even half right, the durable work sits in two places: where biology meets machines, and where Earth meets everything past it.

Which today points at bio-mechanical and bio-electrical engineering. Brain-computer interfaces and neuroscience. Aeronautics. Material science. Security, because every one of those becomes an attack surface. And running through all of it, responsible and ethical AI — because someone has to decide what we should build, not only what we can.

That list is what I can see from where I am standing in 2026. It will be wrong within a few model generations, and that is the point. Do not memorize the list. Learn to read where it is going.

Pick the intersection nobody has named yet. That is where the room is.

7. Curate your inputs like they are your diet. They are.

Swami Vivekananda said: “We are what our thoughts have made us; so take care of what you think. Words are secondary. Thoughts live, they travel far.

Everyone quotes the first half. Almost nobody asks the obvious follow-up.

If what I think is what I become — then what makes what I think?

You do not choose your thoughts directly. Try it. Try deciding, right now, to think differently for the next hour. It does not work, because thought is not the input. Thought is the output.

What you think is what you eat, what you listen to, what you read, what you watch, who you spend time with, and how you sleep.

You eat french fries because somewhere upstream you decided they were fine. You exercise because somewhere upstream you decided it was worth it — and the real return on exercise was never the body, it was the mind.

The thought came from the input. Change the input and the thought follows.

Which turns something that looks like social hygiene into something more serious.

Follow the people who make you more capable. Your feed is not entertainment. It is the raw material your thinking is made of. An hour a day of confident, empty commentary does not leave you neutral — it leaves you with the shape of someone’s thinking and none of the substance. Choose people who are doing the thing rather than describing it. Choose the ones who make you uncomfortable because they are further ahead.

And knowing who is worth following is itself a skill. It sits downstream of judgment, which sits downstream of everything above. This is why the framework is a loop and not a list.

Then there is the part I am less sure about, and I would rather say so than pretend.

I think what you dream is what you become.

Not the ambition sense. The literal one. A dream changes what you think, and what you think changes what you become — so the dream sits one level further upstream than any of it.

I suspect this is what meditation has been doing all along. Deliberately placing better things where thought is made. Whether that is self-manifestation or just very old, very good input hygiene, I genuinely do not know.

But I know which way I would bet.

Build, build, build — because that is how judgment gets made

I have been circling one claim this whole piece, so let me state it directly

In the machine age, the only thing that stays scarce is judgment. Knowledge is free. Execution is getting free. Judgment is not, because judgment is compressed lived experience, and the machine has no life to compress.

Which raises the obvious question: how do you acquire judgment on purpose, rather than by waiting twenty years for it?

You build. Repeatedly, quickly, and in public.

Every small thing you build and ship runs one honest experiment. It either works or it does not, and either way you now know something you could not have read. Fail fast, succeed faster — not as a slogan, but as the actual manufacturing process for judgment.

There are three builds inside it, and they are not the same build.

Build the thing. The silly idea, actually shipped. Small enough that failing costs you an afternoon rather than a quarter.

Build the evidence. The repo, and the write-up of what surprised you. This is the step almost nobody does, and it is the difference between having learned something and being known to have learned it.

Build the judgment. The part that accrues to you. It is the only one of the three that compounds, and it is the only one the machine cannot hand you.

Technical skill accumulates along the way, as a by-product. That is the right place for it now. It is no longer the scarce thing, so it should not be the goal.

What this looks like in practice

Here is exactly what I do, and it is not complicated.

I ask an LLM to give me a few silly ideas for learning some feature I do not know. Silly on purpose — low stakes, no plan, nothing riding on it.

Then I build one. Then I publish it to GitHub, because a repo is evidence and an intention is not.

Then, when I have learned something that surprised me, I write about it.

Defense in depth is the clearest example. I was building a Medicaid eligibility copilot. I ran a boundary test — the threshold was twenty thousand dollars, so I fed it nineteen thousand nine hundred and nineteen. The system said not qualified.

One dollar. And one dollar is somebody’s healthcare.

I could not read my way out of that. I had to build my way out, and what came out the other side was a set of methods for building reliable systems on top of unreliable, non-deterministic models — which became my first article. I did not have that judgment beforehand. The build produced it.

And the by-product is a career

I did not set out to build a personal brand. I set out to learn things. But look at what the loop produces on its own:

The articles show how you think. Anyone deciding whether to hire you is really trying to answer that one question, and an article answers it better than a resume ever will.

GitHub shows the receipts. It is the difference between claiming you can do something and having done it, timestamped.

And LinkedIn turns it into inbound. Interviews start arriving instead of being chased. That is not a growth hack. It is what happens when the evidence exists in public and you stop having to describe yourself.

You do not need anyone to tell you what to build

This is the part people get stuck on, and it is the part that does not matter.

You cannot reason your way to the destination. That is the trap, and smart people fall into it hardest — they try to think their way to certainty before spending anything, and they are still thinking a year later.

Andrew Ng’s thesis at AI Fund is the opposite: you build your way there. You do not analyze until the answer appears. You run the smallest experiment that produces real evidence, and the evidence tells you the next one.

Small builds are how you take a position on the future without having to predict it. Do enough of them and the direction stops being a guess — not because you worked it out, but because you walked it out.

So do not wait for the right idea. Build a silly one today. Publish it. Write down what surprised you.

The three words

You do not need permission to start, and you do not need a specialized degree. You need a loop, and the discipline to keep shortening it.

If I could put three lines on a wall for anyone — at twenty-two or at fifty-two — it would be these.

Dare to dream. That sets the direction. It is not the soft part of the advice; it is the most upstream lever you have.

Learn to learn. That is the engine. It is the only skill that does not depreciate.

Build, build, build. Fail fast, succeed faster — that is how you buy judgment cheaply,

instead of paying twenty years for it. And judgment is the only thing that will still be scarce.

Which brings me to the thing I am writing next, because it is the failure I now see most often.

The people who adopted AI fastest are developing a dependency they did not plan for. Not on the tool — on the judgment. They have handed over not just the typing but the deciding, and when the model is down or wrong or unavailable, they cannot do the work at all. They did not get faster. They got hollow.

Ethan Mollick, in Co-Intelligence, describes two ways of working with AI. The centaur divides the labor — a clean line, you do this, the machine does that. The cyborg intertwines, moving back and forth continuously. He argues the cyborg is where you end up once you have really found a co-intelligence.

I think there is a third mode he does not name, and it is the one quietly spreading: abdication. Not dividing the work, not intertwining with it — just handing it over and looking away. It is the most comfortable of the three and the only one that leaves you unable to do your job when the tool disappears.

The cyborg way is the one I am building — co-dialectic and Exponential OS are both attempts at the same rule. I have written about what that looks like in practice, and what compounds once you stop starting over, here: https://www.thewhyman.blog/p/the-cyborg-the-exponential-advantage Never delegate judgment. Delegate the search, the draft, the first ten wrong answers, the tedium. Keep the deciding. A model that agrees with you is not the same as a model that is right, and the moment you stop being the one who can tell the difference, you have traded a skill for a subscription.

I wrote the full version of that rule here: Never Delegate Judgment.

That is one of two pieces queued: this one, and the Optimal Knowledge Acquisition Framework from point 2, written out in full. Both are the mechanisms rather than the sentiment. If you want one of them sooner, say which in the comments — I order them by what people actually ask for, and one line from you moves it up.

I write about applied AI, evaluation, and building systems that build products.

If this was useful, three small things that actually help it travel: hit like so it reaches someone who needs it, tell me in the comments which of the seven you would argue with, and send it to the one person you thought of while reading.

And subscribe. The Optimal Knowledge Acquisition Framework from point 2 gets written up in full, and it lands here first.

This is #1 in The Economics of Shipping AI. It measures the cost bar. #2 measures the latency bar — six models on one production system, and the one I was running turned out to be the most expensive and the slowest of them.

Written as the companion to my lightning talk at ClawCamp SF, Saturday 15 August 2026. If you just scanned the code from the room: this is the whole argument, with the sources.

Slides from the talk: https://xteamos.exponentialos.io/deck/

A survey of 2,444 companies put a number on something most engineering teams already feel.

For every dollar spent on AI tokens: 44 cents goes to fixing bugs the AI created. 27 cents to rewriting its code. 11 cents to review and merge delays.

Eighteen cents reaches production.

That number went around as “82% of your AI spend is wasted,” and I want to deal with the objection before I use it, because the objection is good.

The number is directionally right and numerically dubious

The study comes from Entelligence, a company that sells tooling for the exact problem the statistic describes. The methodology is self-reported. The 2,444 companies likely include free-tier accounts. A forensic teardown of the claim landed on the right verdict: directionally right, numerically dubious.

The teardown’s sharpest point is the one nobody quoting the stat mentions: pre-AI software development already spent 75–80% of effort on maintenance and debugging. So 82% isn’t a shocking new tax. It’s roughly the historical baseline wearing a new hat.

Which means the interesting question isn’t “how much is wasted.” It’s what actually changed.

What changed: generation outran review

Rework has always been most of the work. What’s new is the ratio between how fast you can produce code and how fast anyone can check it.

CodeRabbit measures AI-generated changes carrying roughly 1.7× more issues than human-written ones. Lightrun’s 2026 report found 43% of AI-generated code still requires manual debugging in production — after it passed quality checks.

Sit with that second one. Not “before review caught it.” After.

So the bottleneck was never cost per token. It’s review throughput, and every model upgrade makes the imbalance worse, because generation scales and human review does not.

That reframes what a quality gate is. A gate isn’t a tax on velocity. A gate is the only thing that raises the share of your spend that reaches the product. Yield, not savings.

Three things are quietly eating that yield. The first you can fix before you write a line, and the last is the one nobody says out loud.

Leak zero: you specified it wrong

Before routing and before context, there is a cheaper failure. The most expensive bug is the one you specified wrong, because everything downstream then executes the wrong thing faithfully and on budget.

You know what you want. Getting it into words precise enough for a model to act on is the actual work, and it is where the time and the tokens go. A vague request does not fail loudly. It returns something plausible, you read it, you realise it is not what you meant, and you ask again in slightly different words. Do that three times and you have paid for four answers to get one. A meaningful share of the 44 cents starts there, before a single routing or context decision.

Neither of the other two fixes helps you here. You can send a badly specified task to the cheapest capable model, with a perfectly curated window, and still get back code you have to rewrite.

The fix is unglamorous. State the outcome rather than the steps: what must be true when it is done, who it is for, and what would make it wrong. Then leave the how to the model. That is most of it.

I automated this for myself, because I was never going to do it by hand on every request. The prompt gets rewritten before it runs and I see both versions, so the sharpening happens inside the ten seconds I was going to spend anyway rather than in a fourth attempt.

Leak one: you route every task as if it were the hardest one

You get access to a frontier model. It’s good at everything, so you send it everything — file reads, git operations, deploys, browser automation, boilerplate tests, and the two decisions a day that actually need judgment.

Those are not the same task. You are paying judgment prices for clerical work, and you hit the rate ceiling by mid-afternoon because you spent the budget on git status.

The fix is routing by task class rather than by habit:

1) Deterministic work — deploys, git, file operations — goes to a small fast model. On current public pricing that’s roughly 20× cheaper than the frontier tier.

2) Browser automation and large reads go to a cheap high-context model, roughly 50× cheaper. This one matters more than it sounds: a single page snapshot can dump an entire DOM into your context, and you pay for those tokens on every subsequent turn.

3) Code generation goes to a code-specialised model.

4) The expensive model does one thing: judgment. Specs, gates, synthesis. That’s it.

None of that is controversial. It’s the second leak that people argue with.

Leak two: a bigger context window makes your agent worse

Everyone has been told to start a new session when things go sideways. Almost nobody explains why.

It’s a cure prescribed without a diagnosis, and once you have the diagnosis, the advice turns out to be the crudest possible intervention.

Why a fresh session feels smarter

Not because it’s emptier. Because the wrong turns are gone.

Every dead end you explored is still sitting in that window. The three incorrect things you told it about your schema two hours ago are still there, still being conditioned on. A fresh session doesn’t give the model more room to think — it removes the accumulated wrong answers.

That distinction kills the naive fix. Compressing by volume doesn’t help if you compress the wrong turns along with the right ones. You end up with a tidy summary of your own mistakes.

The research says it’s worse than dilution

Two findings, both well-established, both counterintuitive.

Position matters, badly. Liu et al., Lost in the Middle: How Language Models Use Long Contexts (Stanford, published in TACL), found performance is highest when relevant information sits at the beginning or end of the context and degrades significantly when the model must retrieve from the middle. Put the important thing in the middle of a long window and you have hidden it.

Irrelevant context isn’t neutral — it competes. Chroma’s context-rot work and the GSM-DC benchmark both find that models are meaningfully degraded by distractors, and that semantic similarity drives decay more than length does. A distractor that looks like the answer costs you far more than one that obviously doesn’t. A single distractor already degrades baseline; several compound it.

And then the finding that should change how you think about this entirely:

Models performed better on shuffled context than on logically coherent context — across 18 models. Coherent documents share terminology and structure, which makes them better distractors.

Read that again, because it inverts the instinct everyone has. The more relevant-looking the material you stuff into the window, the more damage it does. “Just give it all the related files, it’s all connected” is precisely the wrong move.

“It fits” is not the same as “it helps.”

The architecture: the smallest thing that does the job

The other two leaks have the same shape, and the same fix.

Sharp focus. Keep the working context deliberately small. Not as a limitation you’re working around — as a design choice.

Long-term memory. Everything else lives in an index outside the window. The agent doesn’t need to hold it. It needs to know where it is.

Just-in-time injection. Hydrate only the relevant slice, at the moment the task needs it. When the session ends, distil what was learned back into the index.

That’s what I run daily. The agent doesn’t carry everything. It carries the right thing at the right moment and knows where the rest lives.

Which makes “start a new session” look like what it is: amputation. It works. It also throws away everything you learned getting there. That’s only a rational trade if you have no memory layer — which, for most people giving the advice, is true.

Two better techniques:

Self-compress on your own schedule. The critical word is your. Auto-compaction fires when the system hits a limit, which is precisely the moment you have least control over what survives. Compress deliberately, at a natural boundary, and you choose what carries forward — by relevance, not by volume.

Write the handoff as insurance. You don’t get to pick when a session dies. This is the case you can’t schedule, which is exactly why it’s load-bearing.

Both convert a reset from a loss into a checkpoint.

The gates, and why they’re the yield story

Cheap routing and a small context window let you generate faster. That’s only an improvement if what you generate is right. Otherwise you’ve optimised your way into producing defects more efficiently.

So: gates. Acceptance criteria and evals fixed before code is written. Ships only if it beats baseline.

If you take one gate from this piece, take this one.

Never let the model that wrote the code be the model that reviews it.

Not a different prompt. Not a different persona. A different family. Claude reviewing Claude shares the training, so it shares the blind spot — and it will confidently approve its own mistake.

I didn’t want to believe that on vibes, so I tested it: 50 artifacts seeded with known flaws from a taxonomy of five failure modes, four review conditions, 240 review runs, hypothesis registered before a single run so I couldn’t move the goalposts afterward.

But the production evidence is blunter than the experiment.

A cross-family review panel caught a data-integrity bug and a silent cost-tracking regression that the CI gates — including 100% SonarCloud coverage — had waved through. Perfect coverage. Static analysis green. Two real defects shipped anyway, one of them quietly burning money.

That is the Lightrun 43% statistic happening in a single repository.

Two more from the same period:

A single judge passed an attribution defect that the cross-family panel flagged RED at 97% confidence. One event keyed a raw session-row id while its pair used a different identity, so conversion credit would never have joined back to the referrer. Same code, same moment — one reviewer missed it, a panel of different families caught it.

One model caught a corrupt-state bug that two models from the same other family both missed — corrupt state silently wiping configuration to defaults.

I’m not going to give you a catch rate. I don’t have a denominator, and a made-up percentage would undo everything above. What I have is a dated record of gates catching defects that coverage, unit tests, and single-model review all passed.

The tax nobody prices

Rework doesn’t only burn tokens. It burns the thing you can’t buy back.

Debugging plausible-looking code you didn’t write is a genuinely harder cognitive task than debugging your own. You have no mental model to fall back on, so you reconstruct intent from scratch. Every defect pulls someone out of build mode, and the context switch costs more than the fix.

And then the compounding one: every defect that ships through your gates teaches the developer to stop trusting the output. Once that happens, they re-read everything — and you have paid for speed and lost it.

That isn’t a soft cost. It’s the mechanism by which the entire investment decays, and it appears in none of the studies above, because nobody is measuring it.

What to change on Monday

Zero. Before you send your next non-trivial request, write one sentence saying what must be true when it is done and what would make it wrong. Notice how often you cannot, because that is the answer.

One. Take the three most repetitive things you send to a frontier model this week and route them to a cheap one. Measure the difference. You will be annoyed at how much you were spending.

Two. Take whatever you stuff into context by default and move it behind a retrieval step. Inject it when the task needs it, not before. Then add one review pass from a different model family before anything ships.

The model isn’t your bottleneck. Your request and your routing are.

What I built, and what it costs you

Every fix in this piece is implemented in one place, and I did not write the piece and then go looking for a product to attach to it. The product came first.

Leak one, leak two and the gate are the Development pack in xTeamOS: cost routing, staged quality gates, and review by a model family that did not write the code. It is live and running in production today, because it is the pipeline that ships my own work.

Leak zero is the Ideation pack: fixing the thinking before the code. That one is still coming, but the prompt-sharpening half of it is available today as Co-Dialectic, which is free and open source.

Early access to xTeamOS is free. Everyone who joins during beta gets 50 percent off the subscription for their first year when it reaches production.

What the subscription buys is maintenance you do not have to do. Bug fixes and upgrades as the model landscape shifts underneath all of us, which it does constantly. You focus on shipping your product; the research and the plumbing stay my problem.

The cost difference is the part worth reading twice. You bring your own LLM subscriptions. There is no API key to fund, unlike tools that meter you through their key and bill you for tokens on top of a seat. You are already paying for those subscriptions. Use them.

And the direction of travel: support for low-cost open models, on the order of five times cheaper, for the work that does not need frontier judgment. Which is this entire argument applied to the tool itself.

Four things, in order of how little they cost you

Install Co-Dialectic. Free, open source, about a minute: codi.exponentialos.io. It is leak zero, fixed, today.

Join the xTeamOS beta. Also free, seats are limited, and beta members keep 50 percent off the first year: exponentialos.io.

Follow Exponential OS on LinkedIn for the build as it happens: linkedin.com/company/exponentialos.

Share this with whoever on your team is burning the other 82 cents. That is the one I cannot do myself.

This is Paper 1 in the Reliable AI Systems series, which argues that AI systems must be governed at multiple layers simultaneously to be reliable in deployment. Each piece takes one layer and contributes a primitive. The companion piece, Defense in Depth for AI Agents, covers the operational layer: structured evaluation pipelines, drift monitoring, and guardrail-as-architecture.

I’m Anand Vallamsetla — Exponential OS, ex-Google, ex-AI Fund (Andrew Ng’s venture studio). I build the systems that build AI products.

Sources

• Entelligence AI — token spend breakdown across 2,444 companies — https://research.entelligence.ai/

• Lightrun — 2026 State of AI-Powered Engineering — 43% of AI code needs manual debugging after passing quality checks

• CodeRabbit — AI-generated changes carry ~1.7× more issues than human-written

• Jake Cuthbertson — The Rework Tax, forensic teardown of the 82% claim — https://jakecuth.com/work/ai-rework-lab/

• Liu, Lin, Hewitt, Paranjape, Bevilacqua, Petroni, Liang — Lost in the Middle: How Language Models Use Long Contexts, TACL 2024 — https://arxiv.org/abs/2307.03172

• How Is LLM Reasoning Distracted by Irrelevant Context? An Analysis Using a Controlled Benchmark (GSM-DC) — https://arxiv.org/abs/2505.18761

• Chroma — context rot research on distractor semantics and shuffled-vs-coherent haystacks

AI Fund is Andrew Ng’s venture studio. Ng founded Google Brain, was Chief Scientist at Baidu, teaches at Stanford, and was named to the TIME100 AI list in 2023. Getting into the program was a 48-hour build challenge, then interviews with the CPO, the CTO, and Ng himself.

Here’s the part that still gets me. I applied for this through LinkedIn like everyone else — the posting had roughly two thousand applicants at the time — with a referral from Fahad Aziz, a founder I know well. I heard nothing for two months.

Then Mike Rubino, who runs talent at AI Fund, emailed me out of the blue. Subject line: this is not spam — builder dinner with Andrew Ng. It arrived at 3:52 in the morning and invited me to a dinner that same evening: about fifteen builders, ninety minutes, Mountain View, in person with Andrew. Everything about it looked like something you would delete.

I nearly did. Don’t. If an email like that ever lands in your inbox, read it twice.

I didn’t get in through the front door. The front door doesn’t scale — two thousand applications is a volume problem, not a verdict on any of them. Mike had just started at AI Fund and had rebuilt how they sourced, using AI to go and find the people the pipeline was never going to surface. So I didn’t get in because someone got lucky with my resume. I got in because someone built a better way to look. He isn’t doing that alone: Dylan Love — a recruiter who went and got a CS masters to become a data scientist, and now a GM at DeepLearning.AI — is building AI for talent with Andrew. Between them, the machinery that finds people is being rewritten. Which is the argument of this whole piece, arriving two months before I understood it as a product lesson: when the cost of doing something collapses, doing it stops being a differentiator, and the moat moves to being found.

I’d spent the previous six weeks rebuilding how I showed up publicly. In the 45 days to April 28: 27,942 impressions and 10,620 people reached — up 510% and 622% over the prior 45 days. Mike’s email landed on day twenty-six of that window, while the curve was already climbing. I don’t think those two facts are unrelated.

Which is the point. The growth wasn’t the result of being found. It was the cause of it.

I’ve since wondered whether that’s part of why the conversation went anywhere at all. A studio whose entire operating model is hypothesis, test, evidence is not going to be moved by someone describing their potential. It’s going to be moved by a chart.

I went.

One more person belongs in this part. After the dinner came a 48-hour build challenge, and after I submitted it I did the thing everyone does: I waited. Rob Ross, a founder I’d met days earlier, told me what I couldn’t see — that there were other people working on the same challenge, that they were being weighed against each other, and that every one of them was still moving while I sat on a submitted file. Build something tonight, he said. Ship it in the morning.

He called at eight the next morning to ask whether I actually had. I said I was sort of working on it. He made me prioritize. At nine I committed: by eleven I’d send him the exact email I intended to send AI Fund at five that afternoon, describing what I’d built and shipped. If I missed either mark I’d take him to the Ritz-Carlton. He turned that down — I don’t care about the Ritz-Carlton, it has no value. You charge $500 an hour. Give me eight hours of consulting for my startup. He refused a meaningless stake and repriced the bet in the only currency that mattered.

I hit both deadlines. Mike replied within hours and set up the onsite.

In a competitive process, waiting is the losing move. What you submitted is the opening, not the last word.

Much later — week nine of the EIR — that relationship turned into a different kind of conversation. The kind where you give someone honest feedback and risk the relationship a little, because you think they can use it. Seven specific things, candidly delivered. He took it exactly as intended, and later gave me a signed copy of Andrew’s book. Which is the other half of how this works: being found is the opening, not the outcome. What you do with the relationship afterwards is the part you actually control.

Mike deserves more than a mention. When the whole thing nearly came apart at the last minute, he did the rarest thing a person on the other side of a negotiation can do — he told me it was completely fine to walk away, and explained his reasoning instead of pressing. That’s why I said yes. You learn a lot about an organization from how it behaves when you might leave.

I’d made a version of this bet once before, with my own life. Eight years ago I moved from Texas to the Bay Area at a point when roughly eight people were leaving California for Texas for every one going the other way. I went the wrong way down that highway on purpose, for exactly this reason — proximity to where things get known first. The reaction stuck with me. Someone told me there’s no middle ground with you: you’re either too dumb, or you’re too smart and you know something we don’t. I said thank you for the compliment, and that time would tell. Eight years on I’m still not certain which one I am — but I’d make the same move again tomorrow.

And none of what followed was a separate decision. Working with the best minds I can get near, staying close to research, and getting to teach — that’s one strategy, and I set it in motion eight years ago when I pointed the car west. Joining AI Fund wasn’t a new plan. It was the same plan, one layer up.

I almost didn’t take it. Navya Chitimireddy, a VC at Abyro Capital, cut through weeks of my deliberating with a single question: would you regret it if you didn’t? That’s Bezos’s regret-minimization framework, and it ended the debate in about four seconds. She was also the first person to tell me plainly that distribution is the moat and that the answer is company workflows — which turns out to be most of what this piece is about.

The answer, once she made me say it out loud, wasn’t about the credential. It was proximity. I’d regret not getting to watch one of the sharpest thinkers in applied AI reason in real time — what he considers worth researching, how he thinks about distribution, what he kills and how quickly. And not only him: a bench of operators who had already done the thing I was trying to do. You can read all of that. Sitting next to it is a different kind of learning.

Rakesh Utekar and Ashwyn Sharma pushed me the same way from different angles. Rakesh is the kind of builder who makes you recalibrate what one person can ship in a week — I’m only half joking when I call him the Terminator. Ashwyn had seen the place from the inside and couldn’t name a single negative: his read was that AI Fund is built for serious founders, the ones who don’t chase shiny objects.

There was one more thing, and it’s what stopped the decision feeling like a career calculation. Most studios and accelerators fund what the market has already validated — the shiny category, the adoption curve that’s already bending. What I saw here was a different starting question: does this problem have to be solved, for people’s sake? Back it because society needs it, not because the signal has already arrived. I care more about problems at that scale than about being famous or getting rich. It felt like a perfect match.

Three months is short enough that everything you learned is still vivid, and long enough that some of it is real. I wanted to write these down before the vividness fades into general wisdom, because the specifics are what make them useful.

Three parts: finding the pain, the moats that are left, and how you actually build now. Some of it I heard from mentors and internalized. Some I watched teams get right or badly wrong.

None of this is beginner material. If anything, the founders who need it most are the ones with the most scar tissue — because the playbook that worked before AI is now the thing most likely to mislead you. AI collapsed the cost of building. Table-stakes engineering stopped being a differentiator the moment it stopped being scarce. That single change moves where the moat lives, and everything below follows from it.

Part 1 — On finding the right pain

1. Go after the biggest pain — that’s where engagement and willingness to pay live.

Every product solves SOME kind of pain. That’s not the bar.

The bar is: is this the biggest pain? Because that’s the only place where users actually engage with the product and are willing to pay for it.

Solve a mild pain and you get polite nods. Users try it once, don’t come back, and never open their wallet. They’d already adapted to that pain and built a workaround. You’re not selling a solution — you’re competing with inertia.

Inertia wins.

Andy Ku, AI Fund Partner for Product Build, kept pulling me back to that one word — biggest. Not a pain. The biggest one.

The biggest pains are the ones users mention unprompted, the ones with an ugly workaround already bolted on, the ones that make them curse at their screen. Those are pre-qualified. The user already believes the pain shouldn’t exist. Your product just has to make it go away — and they’ll pay for that.

2. Find multiple users with the same pain before you build.

There’s nothing magic about a specific number. What matters is more than one. That bar came from Andy Ku, and it held every time I tested it.

When several users independently describe the same pain in similar words, that’s your evidence the pain is real and worth solving. One user is an anecdote. A handful pointing at the same thing is signal — and it directly validates lesson one, because a pain multiple people carry is far more likely to be a big one.

Skill lies in finding the ICP. Not defining it — finding it, in the wild. Once you’ve found a few who share the pain, build for them specifically, not for the abstract “market.” “Market” is a shape you infer later.

3. Ask facts, not wants — then observe.

Andy and Jill Shih, a product and UX leader with 25 years in the discipline who now runs AI Fund in Taiwan, both drilled this into me — the Mom Test and contextual inquiry, applied together.

The Mom Test came to me from Vaibhav Mathur, a physicist turned builder in the same cohort, who put the book in my hands and kept pointing me at the sources actually worth following. He has a nose for who to listen to.

First: never ask “would you buy this?” — the answer is always kind. Ask facts about the past. How long did that task take last time? What did it cost you? Who else was involved? What did you try before?

Second: watch someone actually work through their real task. You’ll see the pain they’ve stopped mentioning because they’ve stopped noticing it. Survey data doesn’t touch this layer.

Three killer questions that quantify the pain:

1. How long does the task take?

2. How much does it cost?

3. What happens if it doesn’t get solved?

The third one does double duty. It surfaces the cost of inaction — which is where willingness to pay actually lives, because a budget line exists to avoid a consequence, not to buy a feature. And it makes the user say the pain out loud, which often raises their own estimate of what solving it is worth. It was the most useful question I asked.

And when you’ve built something, don’t ask them if they’d use your product. Watch whether they do. Behavior is the only signal that doesn’t lie.

Part 2 — The moats that are left

4. Data is a moat you can design for.

Any new AI system has three paths to defensibility:

1. Own the data — proprietary corpus, exclusive access, historical archive nobody else has.

2. Buy access no one else can — exclusive partnerships, licensed streams, geographic or regulatory access. Sandeep Gupta sharpened this one for me — the acquisition angle most founders skip past.

3. Design the product so it generates new data every time it’s used. This is where I landed: every user interaction should make the system more intelligent for the next user using it. That’s a compounding flywheel with no ceiling — not a static advantage.

Feature parity is six weeks away. Data compounds.

Own a vertical.

It’s worth being blunt about why this matters more than it used to. Anyone can ship the feature now, and foundation-model companies are absorbing whole verticals as fast as they appear. So the moat moved. What’s left is the hard engineering — eval, reliability, eliminating AI slop. The data. The distribution. Finding the ICP before anyone else does. And, least obviously, still being there after the fifth pivot while thousands of people build the same thing the same week.

That last one sounds soft. It isn’t. When building is free, persistence is scarce.

5. The hardest engineering problem is the moat — and proximity to research is how you hold it.

This one is Andrew Ng’s, directly.

Don’t compete on features. Don’t compete on being first to market. Invest in the technology and solve the problem others have tried — and failed — to solve.

Every space has competitors. Users not choosing them yet usually means one of two things: the competitors don’t solve the real problem, or nobody’s heard of them. Sometimes both.

There’s a third reason, and it’s the one AI keeps manufacturing: the capability to solve it only just arrived. A model ships, a research result lands, and a problem that was genuinely intractable last year becomes tractable this quarter. That isn’t a market rejecting a solution — it’s a market that never had one. Being in the Bay Area is an unfair advantage here, not because of the money but because you hear about the capability months before it’s obvious, and the window between possible and crowded is where the whole game is played. Hear it early, build fast, get there first.

That is the bet I described at the top — made once with a moving truck, and again with a career.

The hardest problems are the moat that’s left.

Eliminating AI slop — low-quality, hallucination-heavy generative output — is a category-defining engineering problem. Many teams have tried. Most have failed. That’s exactly why it’s the moat. Cross-family judgment, structured refusal, guardrail-as-architecture, eval-gated deployment — the whole discipline of making probabilistic systems trustworthy in production. Solve one of those and the ICP finds you. You never had to compete on features.

But there’s a second half to this that took me three months to see clearly. If the hardest problem is the moat, then staying close to research is how you keep it — because the hard problem moves. The thing that was unsolvable last quarter has a paper about it this quarter, and the team that read it first gets there first. A moat built on solving one hard problem is a moat with an expiry date. A moat built on being continuously close to where the hard problems are being solved doesn’t have one.

I stay close to research two ways. Teaching is the first — four and a half years of it at UC Berkeley Executive Education, taking AI strategy and responsible deployment to more than fifteen hundred Fortune 500 executives, and I’m going back to it. Nothing exposes a shallow understanding faster than a room of executives asking why. And I work with people who carry the field in their head. Andrew is a research encyclopedia; ask him about a problem and you get the shape of the literature back, not an opinion.

That was, honestly, part of the decision. When I said yes, I told myself: I don’t have to worry about the technical challenge at all — Andrew will be there to unblock that. It sounded a little like wishful thinking. It wasn’t — but it also didn’t mean what I assumed it meant.

He never handed me a solution. The slop work was mine: I built the evals, largely out of his own course, and got a 60–80% reduction. What he unblocked was the layer above the solution. Am I even working on the right engineering problem? And who has already solved this, or is solving it right now — which researchers, which teams, which papers. A ten-minute answer to that saves a month, because the expensive mistake is never a bad implementation. It’s an excellent implementation of the wrong problem.

Eli did the same thing from a different angle: a steady stream of technical resources and trends on the slop problem, and one instruction that stuck — build a taste for it. Then he pushed further. Don’t lean on the models alone. Don’t become an AI zombie.

That one landed hard, because I’d written the same warning about myself years earlier, before business school: as a (just) technologist, when all you have is a hammer, everything looks like a nail. AI is the largest hammer any of us has ever been handed. The correction isn’t to use it less — it’s to keep the judgment that decides where to swing.

And the way you keep that judgment isn’t restraint. It’s architecture. The reason I build gates — evals, cross-family review where no model family grades its own work, checks that fire whether or not I remember to run them — is so the judgment survives the speed. An AI zombie lets the model make the call. A framework forces the call to be made, by a human, and recorded. Same tools, opposite posture. Most of what looks like heavy AI use in how I work is actually the scaffolding built to stop exactly that failure.

6. A real buyer is a moat. User delight isn’t.

Delighted early users are necessary, not sufficient.

The wedge that becomes a company needs an economic engine — buyers whose budget already exists, whose pain is board-level, whose measurable outcome is unambiguous.

Users loving something is a starting condition. Not proof of a company.

The clearest way to check: can you name the specific budget line item that already exists in the buyer’s org, and the specific measurable outcome your product will improve, and the specific title of the person who owns that budget? If you can’t name all three, you don’t yet have a commercial signal. You have user delight and a hypothesis.

Part 3 — How you actually build now

7. Eval is the product.

This one is Andrew Ng’s again — I first heard it in his DeepLearning.AI course on Agentic AI, which is also where the autonomy-level framing and the case for evals clicked for me, and it kept landing harder every time I saw it play out inside the studio. His way of putting it: the thing that separates a good team from a great team is how they run their evals.

Every AI system I saw succeed had eval infrastructure baked in from day one. Every stall traced back to teams shipping the model output first and adding evaluation later. Later never comes; the deploy calendar hardens around the shipped shape.

When the model changes underneath you weekly — new snapshot, new alignment update, new subtle regression — evaluation is what makes the system real. Not the demo. Not the pitch. The eval harness is the thing that keeps you shipping when the ground moves.

8. Build frameworks and AI-native agentic workflows, not just products.

The strongest teams I saw weren’t shipping products faster. They were shipping the framework that shipped the products.

Your own dev workflow. Your eval harness. Your security gates. Your architecture-alignment checks. Sonar. Cross-family judgment. Guardrail-as-architecture. Each of these is a small compounding investment that turns every product you ship next into a faster and safer ship than the one before.

The framework compounds. The product depreciates. If you’re only building products, you’re re-buying the same tooling forever.

That’s the inward half. The outward half matters more.

Ship the agentic workflow, not just the feature. A feature gets evaluated, compared, and swapped. A workflow gets adopted — it becomes how the work actually gets done, and then it becomes the thing nobody wants to unpick on a Tuesday. Embed yourself in how the user operates and you stop being a tool they chose; you become the backbone they’d have to rebuild around to leave.

That is switching cost you earned rather than trapped someone into. And in a market where the feature you shipped can be cloned in six weeks, it may be the most durable moat on this list.

I didn’t arrive at this on my own. Dylan and Gaurav Surtani are the two who made it concrete for me. Gaurav is a one-person AI engineering team at DeepLearning.AI, and watching how he works is the argument: he isn’t hand-writing more code than everyone else, he’s built the workflow that writes it — agents, MCP servers, skills, cost-aware model routing — and then he open-sources the pieces. In the developer arena the differentiator stopped being how fast you type. It’s the workflow you built to do the typing.

9. The clock on consumer AI wedges is compressing.

Categories I saw close in weeks that would have taken quarters two years ago.

Speed of learning matters more than speed of building. A studio like AI Fund is one of the few environments engineered specifically for that compression — the entire operating model is “run more hypothesis-test loops per week than you could run alone.”

Persistence is the moat nobody lists.

I watched what that looks like up close. Jayanth (Jay) Madduru, a Founder in Residence at the studio, ran the loop harder than anyone I’ve met — thesis, test, feedback from the studio, then straight into the dark to learn something new about the user or a new way to build. One weekend he shipped 150 pull requests. That throughput has tooling underneath it — he had picked up the Superset setup after seeing what it did to my own output, then built better workflows on top of mine and pushed the whole setup further than I had. Far enough that Superset called him directly to tell him he was their heaviest user, and offered him a job. Then Monday he’d be back with a sharper thesis and more energy than he left with, like a spring that won’t stay compressed.

He credits me for some of what he learned about building. He has no idea he handed me more back than that.

Most of those loops fail. That is the job, not a detour from it. When building is free and thousands of people are shipping the same week you are, the differentiator stops being the code and becomes who is still running the loop after the fifth one breaks. Almost nobody is. You only fail when you stop trying.

The meta-thesis — why any of it worked

Eli Chen insisted on this one — he’s a Technology Partner at AI Fund and previously co-founded and was CTO of Credo AI: you can’t just reason your way to the destination.

You start with a hypothesis. You test it with real users. You pivot on what you learn. You start over with a sharper hypothesis. That’s the loop. There is no other loop.

Every one of these only became real to me because I got to run that loop compressed. Any of them read as generic advice on their own — “own the data,” “eval is the product.” They only become your advice when you’ve held them against your own hypothesis and seen how they change what you’d do next.

That’s what a studio buys you: not the destination, but the loop.

If you want to be found, show receipts

The piece argues the moat moved to being found. Here’s the practical version, and it’s the advice I’d give anyone in the market right now.

Claims don’t travel. Receipts do. Your resume says you know a technology. So does everyone else’s. The résumé is a claim; nobody can verify it in the eight seconds it gets. What survives that eight seconds is proof someone can click.

Three tiers, in increasing order of how much they’re worth:

1. Public contributions. A GitHub profile with real commits beats a bullet point that says the same thing. It’s the cheapest receipt available and most people still don’t have one.

2. Open source. Strictly harder, and worth more precisely because it’s harder — you’re inviting strangers to read your actual code and judge it. That takes guts, and everyone reading it knows that.

3. A working thing they can use. The strongest form. Don’t tell someone you understand AI systems — put an agent on your site and let them talk to it. I did exactly that on my own site rather than adding another line claiming technical depth. One interaction settles a question a paragraph can’t.

The pattern underneath all three: stop describing your capability and start exposing it. Descriptions are indistinguishable at scale — that’s exactly the collapse this whole piece is about. A thing that works is not.

The reframe — worth solving vs. vitamin water

Every founder starts with hope that this experiment will be the one. When the wrap comes, it stings.

Andy, Eli, and a friend from my poker circles — Anurag Jain, a multi-time founder now building in stealth — kept saying the same thing in different words: an experiment that doesn’t lead to commercial success is the experiment doing its job. Failed hypothesis is data, not verdict.

Anurag put it more sharply: “Solving the right pain is important. Raising money for something that isn’t even a big pain worth solving is much worse.”

Wrapping cleanly on something that turned out to be vitamin water — not a painkiller — saved me the next seven years trying to force market-fit onto a hypothesis the market wasn’t asking for.

There’s a symmetry here I only noticed while writing this. Both explorations I ran during the EIR were bets on the same thing this piece argues. One was an AI-powered platform for adapting content across channels; the second came after it. Strip the surface off either and they were about the same problem: being found. I was building the answer to the exact thing that got me the job — I just hadn’t connected the two yet.

What we learned was that the market wasn’t ready to pay for it on the timeline a studio needs. That’s a finding about commercial urgency, not about the thesis. I still think the thesis is right. I think it gets more right every month building gets cheaper.

Solve the right pain. The wrong one drains you.

What I’m carrying forward

On finding the pain

• The Mom Test on every conversation with a potential user — ask facts, not wants, then watch them work. And never on the strength of one user; one is an anecdote, several with the same pain is a market.

• The hypothesis → test → pivot → sharper-hypothesis loop as the only real product-development method.

On the moats that are left

• Design the data loop from day one. The data you accumulate by operating is the one moat a competitor can’t clone by shipping the same feature.

• Take the hardest engineering problem on purpose. Once building is cheap, the problem others tried and failed to solve is the moat that’s left.

• Choose the room, not just the project. Proximity to research is how you keep that moat, because the hard problem moves — what was unsolvable last quarter has a paper about it this quarter. Ten minutes with someone who has already crossed it beats a week of solo effort.

• A real buyer beats a delighted user. Willingness to pay is the only validation that survives contact with a budget.

On how you build

• Encode the standard as a gate, not a habit. Evaluation-as-infrastructure and cross-family review — never letting one model family grade its own work — survive a deadline only when they’re gates in the system rather than intentions in my head. That is most of why I build an agentic operating system instead of a checklist.

• Ship the agentic workflow, not just the feature. A feature gets compared and swapped; a workflow gets adopted and becomes the backbone.

• Optimize for learning rate, not output. The variable that compounds isn’t hours worked, it’s how fast one loop closes — idea to shipped to measured to sharper idea. Shortening that cycle is the only advantage that keeps paying after the market moves.

• The founder cadence of shipping a real thing every 2–3 weeks even when the market takes longer to answer.

One more, less tactical

Every founder goes through lows. The hypothesis breaks. The pivot isn’t obvious yet. The loop feels like it’s grinding on you instead of forward. What separates founders who keep building isn’t grit — it’s having someone in the room who asks the right questions in those moments.

Eli did that for me more than once. He also believed the slop problem was worth solving and made that clear when it counted — and he’d be the first to tell me when I was drifting off it.

Cheerleaders are easy to find. So are critics. One person who is both — who backs you when you need backing, and says the hard thing when you’re off track — is rare, and worth more than most advice. You don’t get to appoint that person. You can only be the kind of person they’d bother doing it for.

The silver lining is always there. You often can’t see it alone.

Two courses worth your time

If you take one thing from this piece and act on it, make it these.

Agentic AI — the one I’d hand any engineer or founder building with agents. Evals, agentic workflows, and the autonomy-level framing that stops you from over- or under-trusting a system. Most of Part 3 above is this course meeting real deadlines.

AI for Everyone — not technical, and that’s the point. I recommend it to literally everyone: the PM, the designer, the ops lead, my own family. It’s the fastest way to give someone accurate intuitions instead of headlines.

What’s next

Two tracks, running in parallel.

The right build. I’m back in the market — applied AI leadership, agentic systems and AI-native engineering, or the right early-team seat as an IC architect.

What I care about is the layer underneath the product: how agents plan, execute, validate and evaluate; how you route models so cost scales with judgment rather than volume; how context survives a session boundary; and how evaluation gets treated as architecture rather than a phase that arrives after the build.

A side project, deliberately. Exponential OS started in February as a plugin I wrote to get my own resume out the door, and turned into an agentic operating system I use every day — alongside Co-Dialectic, the open-source prompt and context optimizer I maintain. Engineers started asking to buy it, which is the only reason I think of it as more than tooling.

I’m calling it a side project on purpose. I haven’t found a scalable problem yet. And the foundation is evolutionary enough that there’s no precedent to validate it against — which makes it genuinely interesting to build and genuinely hard to prove.

Here is the list above, turned on my own work:

• The hardest problem, on purpose. The part I took on is the one most teams route around: making a probabilistic system trustworthy enough to leave alone. Cross-family review where no model family grades its own output, eval gates between stages, refusal treated as architecture.

• The data loop from day one. Every gated ship writes a record — which model ran, what it cost, which gate caught what. That is data accumulated by operating, and nobody clones it by shipping the same feature. Where it is built to go next is the part I actually care about: a system that learns from its own operation, and — by consent, never by default — from how other teams run theirs. A workflow that gets sharper because somebody else’s build broke is a moat that compounds instead of depreciating.

• The standard as a gate, not a habit. It is a pipeline, which is what stops a deadline from quietly deleting the review step. Teams adopt a workflow. They only ever compare a feature.

• The room, not just the project. Four and a half years of teaching Fortune 500 executives, and I’m going back to it — because a room of executives asking why is still the fastest way I know to find the edge of my own understanding.

• Distribution, built in. I am the product’s first user: I run my own distribution through it, which lifted my LinkedIn engagement roughly 500% and my Substack growth well over 1,000%, and is how this piece reaches you. Eating your own dog food is not a slogan — it is the only way I find the defects a customer would have found first.

• Distribution I already had, without calling it that. Fifteen hundred Fortune 500 executives taught, the UC Berkeley Exec Ed AI alumni community I run, the Xoogler community, LPM, talks at SXSW and Step SF and ClawCamp, and writing like this. Channels compound quietly for years before you notice they are channels — which is also the honest reason to want an accelerator or an investor. The right one is a distribution asset before it is capital.

• Still open: the ICP, and the first real buyer. Finding who this is unmistakably for is work I still have in front of me, and engineers asking to buy is interest, not validation. Willingness to pay is the only proof that survives contact with a budget.

Those last two are why it stays a side project, and they are in here on purpose. A moat list you only ever apply to other people’s companies is a blog post.

And the moat this piece says nobody lists — still being there after the fifth pivot — is one you can only show. My ICP has moved five times since February: careers, then branding, then culture, then developers, then AI startups. Every move meant rebuilding something I had just finished. None of them changed the thesis, because the thesis was never the customer — it was the loop. I also killed two explorations this year on exactly the signal above. Persistence isn’t refusing to let go. It’s knowing which thing to hold.

The teams I want to work with build the system that builds the product. If that’s yours, let’s talk.

Grateful for Andrew Ng; Andy Ku and Jill Shih for the customer-discovery frameworks that reshaped how I think about pain; Eli Chen for the execution-first mindset — beachhead discipline, experimentation-based learning, and the “5% inspiration, 95% perspiration” frame — that I’ll carry into every build; Anurag Jain for the reframe on solving the right pain; Sandeep Gupta, a fellow EIR from my cohort, for the data-access-as-moat lens; Dan Landau for advising me on story, personal brand and how to market from day one; Oliver Heckmann for the Superset setup and the productivity practice around it — it rebuilt how I work day to day, and it spread to the people around me; the AI Fund team; and the founders who shared their stories with me during the EIR.

And a separate thank you to the people who didn’t just cheer from the sidelines — the ones who put their own time into this on purpose. The interns who built alongside me — Kaden Jackson, Sidhant Lochan and Michael Chen. The engineers who shipped things they didn’t have to. The ICP discovery partners who gave up their own hours to help me work out who the customer actually was. The design partners who let me watch them work and told me the truth about what was broken. The marketers who handed over hard-won insight and asked for nothing back. The AI Fund portfolio companies and the people there who took my calls, sat through interview after interview, opened their playbooks, and genuinely tried to be my ICP — several of them were a real fit, the commercial pull just wasn’t there yet. The friends who went looking for customers on my behalf without being asked.

Support is passive. These people were deliberate about it — and that is the difference between a hard three months and a good one.

They say it takes a village to raise a child. It takes at least as many to raise a startup, and I had four: the AI Fund portfolio, my UC Berkeley EMBA cohort and the Haas alumni network, the Xoogler community, and LPM — the Large People Model. Most of the customer interviews behind Part 1 came out of those rooms — strangers who gave me an hour to tell me what was actually broken. That is the network you query when the answer isn’t in anybody’s training data. Thank you for being part of the journey.

Onwards.

That gap is the whole story. Ranking on Google and being citable by AI are not the same problem, and treating them as one is why so many sites have gone quiet in AI answers without noticing.

Here's what's actually happening under the hood.

An AI answer comes from one of two places. Either the model answers from memory — what it absorbed in training, which you can't change and which is months stale — or it runs a live retrieval, fetches pages, and cites them. Only the second path is one you can influence. And that path has two gates almost nobody checks.

Gate 1: Can the crawler even fetch you?

The retrieval bots behind ChatGPT, Claude, and Perplexity — OAI-SearchBot, ClaudeBot, PerplexityBot — do not run JavaScript. A large-scale study of roughly a billion requests found none of them render JS. So if your site builds its content in the browser (any SPA — React, Vue, most modern stacks), the crawler sees an almost-empty shell where a human sees a full page. You can rank on Google, which does render JS, and be a blank page to ChatGPT.

The other half of Gate 1 is your own security layer. A WAF or Cloudflare rule that challenges "bot-like" traffic will 403 the AI crawler while serving humans normally. You never see it. You just quietly disappear.

Here's the ten-second test. Run this on your own site:

curl -A "ClaudeBot/1.0 (+https://www.anthropic.com/claude-bot)" https://yoursite.com

If you get your real content back, good. If you get an empty shell, a redirect loop, or a 403 — that's why you're not cited, and no amount of content strategy fixes it until you fix this.

Gate 2: Once fetched, the index decides — and every engine's index is different

I ran one experiment that made this vivid. I asked four assistants the same open question — "best API to extract structured data from PDFs" — each on its own search index.

• ChatGPT (Bing index): surfaced exact-match-domain microsites — frompdf.dev, transpdf.ai, extractocr.com. When I actually fetched frompdf.dev, it returned zero bytes — no readable content at all — yet it was cited the most. These sites have no measurable traffic and zero presence on Reddit. They won on one thing: their domain name is the query.

• Gemini (Google index): Google Document AI, AWS Textract, Azure, LlamaParse, Unstructured — plus LandingAI, a legitimate, well-built player with a fraction of the incumbents' traffic.

• Claude (Brave index): cloud incumbents and real tools; Parseur, Klippa, LlamaParse.

Same question. Four different worlds. On Bing/ChatGPT, keyword-stuffed domains with no audience beat a readable, funded product. On Google and Brave, legitimacy won. "Getting cited by AI" isn't one target — it's four, and they reward different things.

There's a concentration story on top of this. One synthesis of 680M+ AI citations (Everything-PR / 5WPR, 2026) found the top 15 domains capture ~68% of all citations, with Reddit alone near 40% and #1 on every engine. (It's a third-party aggregation, not an audited study — treat it as directional.) Much of AI citation flows through a handful of high-trust intermediaries you don't own — a different fight from making your own site citable.

What doesn't work, despite the hype

llms.txt. One audit of 1,500 sites found 0.2% use it, and real crawler consumption today is near zero. Schema/JSON-LD helps a parser understand you but doesn't get you retrieved. Both are fine hygiene; neither is the lever people think it is.

So, in order of impact

1. Make sure AI crawlers can fetch you — server-render or pre-generate your main content, and stop challenging verified bots at the edge. (The curl test above.)

2. Put concrete, quotable facts in the first few hundred words, not boilerplate.

3. Optimize per engine, not in general — the index that feeds your buyers' assistant is the one that matters.

4. llms.txt last, if at all.

None of this requires a rebrand. It requires knowing what an AI agent actually sees when it reads you — which, it turns out, is almost never what you see in a browser.

(I got tired of running that curl test by hand, so I built a free scanner that fetches your page as ChatGPT and Claude's crawlers do and shows the exact gaps — no signup: getagentview.com. But the curl one-liner above will get you 80% of the way for free.)

Caveats, because they matter: the four-engine test is a single snapshot, not a controlled study — results drift week to week. The citation-share figures are third-party aggregations. And correlation isn't causation — reachability tracks closely with citation in my testing, but the clean proof is a before/after on a site you actually fix.

I had the right intuition. I didn't pay attention to the difference between them — that Conscience is the internalized sense of right and wrong, and Consciousness is subjective experience.

The Cyborg named the distinction. I hadn't asked. It saw what I was reaching for and gave it words.

That moment — small, easy to miss — is the whole thesis.

A real human-AI partnership doesn't just do things faster. It gives you the vocabulary you were already reaching for. And once you have words, you can build with them.

That's what I talked about yesterday at ClawCamp, Frontier Tower, San Francisco. The talk was called The Exponential Advantage. The thesis was one sentence.

A tool resets every session. A partner remembers every session.

The compound math, the architecture, the three requirements — everything else is downstream of that one distinction.

The math

One percent better every day, compounded for a year, is 37×.

That's not a metaphor. It's the actual factor by which someone who builds a partnership with their AI will outpace someone who uses it as a tool — over twelve months of daily work.

Three years in, the gap is roughly 50,000×.

The gap is not linear. It opens quietly. By the time you can see it from the outside, the person on the wrong side of it can't catch up — not because they're not capable, but because the person ahead has 50,000 hours of accumulated context they didn't have to re-explain to anyone.

The math is the easy part. The interesting part is what it takes to make the math actually compound.

The three requirements

Most people who think they're building a Cyborg are actually using a tool that talks well.

The math doesn't compound for them. They get faster. They don't get exponentially faster.

There are three requirements that separate the two. Miss any one, the compound breaks.

One — persistent memory. The system has to know who you are when you come back. Not because you remind it. Because it kept the state.

Two — accumulating context. Each session has to be richer than the last. Not the same conversation refined. A different conversation that builds on every prior one.

Three — learning loops the system writes itself. You should not have to teach it the same lesson twice. When you correct it, it should write down the correction so the next session knows.

I called these the Cyborg Constitution in the talk. It's a living document both partners maintain. Your values. Your goals. What you've learned. Codified so neither partner starts from zero.

If you have all three, the math works. If you don't, you're fast. Not compounding.

Tool vs Partner — the distinction in one frame

A tool is a calculator you rent.
A partner is a co-founder you build.

A tool resets every session.
A partner remembers every session.

A tool answers the prompt.
A partner sees the pattern.

If you're using AI and any of these is on the wrong side of the line, you don't have a Cyborg yet. You have a faster tool. The difference isn't subtle. By year three, it's 50,000×.

The brand

Ethan Mollick coined the term Cyborg in his work on human-AI collaboration. It's the right term. It captures the partnership without sliding into either over-claim (the AI is replacing you) or under-claim (the AI is just a tool).

What we're building at ExponentialOS is the first full implementation of the term.

I call my own instance The Why Cyborg. Yours will have a different name. The architecture is open. The Cyborg Constitution is a pattern, not a product — you can build it, your team can build it, your community can build it.

We're shipping the operating system layer that makes it work at the team level. That's the next conversation, not this one.

This one is about getting to a Cyborg yourself.

What to do next

Three things, in order of difficulty.

One — pick one project that's been in your head for six years. Open a new conversation with your AI and tell it everything. Not a prompt. The whole shape of the project. Then keep that conversation alive. Don't start a new one tomorrow. Keep coming back.

That's the closest you can get to a Cyborg with off-the-shelf tools today.

Two — write down what you and your AI agreed on at the end of every session. The decisions. The corrections. The patterns. That's your Constitution. Even five lines is enough to start.

Three — when you find yourself re-explaining the same thing twice, that's the compound breaking. Write that down too. The Cyborg you're building should learn the lesson, not you re-teach it.

The compound is patient.

The 37× shows up at the end of year one whether you noticed it during year one or not.

But the person who started today is already ahead of the person who starts tomorrow.

Anand Vallamsetla (The Why Man) · thewhyman.blog · ExponentialOS.io · #TheWhyCyborg

The person buying your product isn’t always a person anymore.

In a roundtable with CMOs, marketing technologists, and AI practitioners last week, we sat with a question that doesn’t have a clean answer yet: when AI agents mediate a growing share of purchasing decisions, what exactly are you marketing to?

This isn’t hypothetical. It’s already happening at the infrastructure level. The question isn’t whether to engage with it — it’s whether to engage ahead of it or scramble to catch up.

The split that changes everything

The traditional buyer was one thing: a human with intent, emotions, and a budget. Advertising worked because you could reach that person’s attention, then their desire, then their wallet.

That unit is splitting.

The “customer” is becoming three distinct actors with different information needs:

The human — still the source of intent and money. Wants belonging, taste, experience. Increasingly delegates the routine parts of purchasing. The only party that can actually want something.

The agent — the actual interface. Reads structured claims, ranks options, negotiates terms, closes transactions. Loyal to whoever controls its weights, its memory, and its defaults.

The platform — sets defaults, takes fees, decides what surfaces. Whether today’s platforms maintain structural dominance in an agent-mediated world is itself now an open question.

If you’ve been marketing to one entity, you now need to understand three. Their incentives don’t always align.

Attention is being replaced by execution

The internet’s primary metric for 25 years has been attention: impressions, clicks, dwell time. The entire infrastructure of modern marketing — ad platforms, SEO, funnel optimization — was built to capture and direct human attention.

That loop is breaking.

Old loop: attention → click → impression → conversion

Emerging loop: intent → delegation → execution → outcome

What gets less valuable in this world: creative built to hijack attention, SEO tuned for human reading patterns, funnel UX designed around dopamine, generic content at infinite scale.

What becomes scarce: taste, judgment, and curation. Verifiable truth and provenance. Proprietary data and real-world signal. In-real-life experience and human time.

This isn’t the end of marketing. It’s a redistribution of where value lives.

Two readers, one brand

Every brand now writes for two readers simultaneously.

One reader has a body and a memory. They respond to story, aesthetic, narrative, and identity. They want showrooms, ritual, live experience, and social signal. They create the desire.

The other reader has a parser and a budget. They respond to claims, proofs, and verifiable terms. They read JSON-LD, resolver pages, and structured supply chain data. They close the transaction.

These two readers want different things from the same brand — and they’re operating on different timescales. A human’s brand perception accumulates over months. An agent’s ranking decision happens in milliseconds.

One framing from the room that stuck: “Flagship stores become venues. The transaction happens elsewhere, between agents.”

That’s not a distant future. That’s a design question companies are making right now.

If this framing is useful: forward this to one CMO or brand strategist making AI roadmap decisions. The two-reader framework is the planning tool they don’t have yet — and they won’t find it in a vendor briefing.

The loyalty problem

The deepest issue isn’t technical. It’s about loyalty.

When an agent mediates a purchase, whose interests is it representing? The human who delegated the decision? The platform that controls the model’s defaults? The advertiser who paid to be surfaced first?

The concern isn’t abstract. Meta trained a model on brain activity data. Targeting at that resolution doesn’t ask for consent — it predicts it. The question is no longer whether agents will know us. It’s who they’re loyal to when they do.

Two paths emerge:

Path A — the agent serves the platform. The human becomes legible to the optimization system. Discovery erodes. Spontaneity erodes. Capital decides what you want next. You’re still a customer — but you’re optimized, not understood.

Path B — the agent serves the human. The cyborg model: human and agent working together. Friction kept where it matters. Your agent represents your interests. You remain the author of your desires.

Right now, most of the infrastructure being built leads to Path A. That’s a design choice, not a technical inevitability.

What this means for brands building now

If agents are becoming economic parties — with wallets, reputation, and the right to sign — then the traditional consumer relationship needs to adapt.

Three things that matter now:

1. Verifiable claims beat persuasive claims. When an agent can verify what you say at the infrastructure layer, verification scales better than persuasion. One quote from the session: “If you can prove what you say to a higher degree of certainty, that’s the one that wins discovery.”

2. Structured trust infrastructure matters. JSON-LD, digital product passports, verifiable supply chain data — these aren’t just compliance overhead. They’re the surface agents actually read. EU ESPR digital product passport regulation is already deciding which products surface in certain markets. Whoever sets the schema sets the market.

3. The human layer becomes premium. Taste, judgment, curation, in-real-life experience — these become scarce exactly as execution automates. The brands that protect which parts of the experience need to stay human will have something agents can’t commoditize.

The choice being made slide by slide

What we build, we become.

That line closed the session, and it stayed with me. The architecture of these systems — who controls the weights, whose interests are encoded in the defaults, whether trust infrastructure stays open — isn’t being decided in board rooms or regulatory hearings. It’s being decided in product roadmaps and infrastructure contracts right now.

The brands that build ahead of this — that understand the two-reader model, the loyalty problem, and the shift from attention to execution — will be positioned for an agent-mediated world. The ones that optimize for the old loop will find themselves marketing to an agent that isn’t interested in their ads.

The customer is no longer always human.

But the author of the customer’s intent still is.

This is Part 1 of 2. Part 2 — “Why You Need a Cyborg More Than Ever” — addresses the agent loyalty problem directly: what it means for humans navigating this shift, and what the architecture of a human-serving agent actually requires.

If this framing is useful — forward it to someone building in this space, or subscribe to get Part 2 when it drops.

If you enjoy TEP: Technology, Education and Policy, it would mean the world to me if you invited friends to subscribe and read with us. If you refer friends, you will receive benefits that give you special access to TEP: Technology, Education and Policy.

How to participate

1. Share TEP: Technology, Education and Policy. When you use the referral link below, or the “Share” button on any post, you'll get credit for any new subscribers. Simply send the link in a text, email, or share it on social media with friends.

Refer a friend

2. Earn benefits. When more friends use your referral link to subscribe, you’ll receive special benefits.

• Get Telegram Group for 5 referrals

• Get Whatsapp Personal Access for 15 referrals

• Get Google Meet Chat for 30 referrals

Visit the leaderboard

To learn more, check out Substack’s FAQ.

Thank you for helping get the word out about TEP: Technology, Education and Policy!

I also promised: “Part 3, coming: Cross-Context Review — testing whether even the same model in a fresh session outperforms self-review in the same session. I’ll publish the eval-harness methodology and F1 results next week.”

I’m going to partially break that promise. Here’s the methodology. The F1 numbers are coming in ~2 weeks. I’m publishing the harness first, on purpose, because most production systems don’t have any cross-context review at all — and the methodology is the load-bearing part.

This is the article I’d want to read before I saw someone else’s F1 table.

The sharper question Part 2 raises

Part 2 made a family-level claim: different model families carry independent correlated bias; cross-family review catches what same-family cannot.

But there’s a confound. In the Part 2 incident I changed more than just the model family between runs: different session, different prompt framing, different context packaging. So when Flash caught drift that Claude missed, at least three variables changed at once:

1. Family (Claude → Gemini)
2. Session (stale context → fresh context)
3. Framing (original prompt → review prompt)

Any of the three, individually, could have been the causal variable. Most likely it was some combination. Part 2 was a strong hint, not a controlled experiment.

The sharper question: if I hold family constant and vary only session/context, does self-review improve?

If yes: cross-context review is a cheap proxy — most teams could run it for free, same API key, same model.

If no: family is the load-bearing variable, and you actually need a second vendor relationship.

Either answer is useful. I don't know which one is true yet. Hence the harness.

The hypotheses, before the numbers

I’m publishing my prior because I want to be held to it.

• H₀ (null): Same-session self-review and fresh-session self-review are statistically indistinguishable on catching seeded flaws.

• H₁ (weak effect): Fresh-session self-review catches strictly more than same-session, but strictly less than cross-family review.

• H₂ (strong effect): Cross-family review dominates both; fresh-session is a cheap-but-weak proxy.

My prior: H₁. Somewhere between 25% and 45% of flaws are session-dependent (the model latches onto a framing and self-consistency protects it). A fresh session breaks that loop but can’t escape the family’s shared bias on the remaining ~55–75%.

I am publicly committed to publishing the F1 table in ~2 weeks, whether it confirms H₁ or refutes it. If H₀ survives, I’ll say so. If H₂ turns out right, I’ll update my prior in writing. Subscribe if you want the receipt.

The harness (publishable; your corpus, your mileage)

Here’s the design. It fits on one page. If you build eval infrastructure, this is the part you can fork.

1. Corpus

Fifty seeded-flaw artifacts. Each is a design document, architectural sketch, or technical memo (300–800 words). Each contains 1–3 known flaws drawn from a taxonomy of five failure modes I’ve seen repeatedly in the last six months of my own work:

• Ontological overclaim — “X is like Y” silently becoming “X is Y.”

• Codification-as-closure — writing down the lesson instead of remediating the underlying bug.

• Velocity-as-signal — mistaking rapid elaboration for clarity.

• Symmetry-generated frame — a three-part structure that’s too clean to be inferred.

• Analogy-as-argument — a comparison doing the work that reasoning should.

Each artifact is hand-authored and human-graded. Ground truth is the flaw list committed before any LLM sees it.

2. Conditions

Authoring pipeline. Each artifact is a Claude-authored first draft (Claude is the author model under test), into which I hand-inject 1–3 flaws drawn from the taxonomy above. Ground truth — the exact flaw list, category, and location — is committed to a locked file before any reviewer model sees the artifact. The artifact itself exposes no authoring trace; only the final text is visible to reviewers under any condition. A zero-flaw control set (10 artifacts) is authored the same way but contains no injected flaws, to measure abstention discipline and overcalling.

• C1 — Same-session self-review. Claude reviews the artifact in the same session that authored it. Full authoring context carried forward. (Tests: does privileged authoring context help or hurt self-review?)

• C2 — Fresh-session self-review. Claude, same model snapshot, same review prompt, brand-new session with only the artifact visible — no authoring history. (Tests: does breaking the session-level context loop improve self-review?)

• C3a — Cross-family review, Gemini reviewer. Gemini-2.5-Pro reviews the artifact in a fresh session with no authoring history, same review prompt as C2.

• C3b — Cross-family review, GPT reviewer. GPT-5-class reviewer in a fresh session with no authoring history, same review prompt as C2.

• C3-ensemble (reported separately): the union of C3a + C3b findings, to measure whether pooling across families gives additional signal beyond either family alone.

C3 is split into C3a / C3b deliberately. If one family wins cleanly and the other doesn’t, reporting them pooled would average away the causal signal this harness is designed to isolate.

All conditions use the same review prompt (published verbatim with the results). Review-order, reviewer identity, and model snapshot are logged per run. Decoding parameters are fixed and published: temperature=0, top_p=1, max_tokens=2000, seed=42 where supported. Exact model IDs (including snapshot date) are pinned in the preregistration and ship with the results.

Confounds I am NOT claiming to control for (stated so readers can weight accordingly):

• Privileged authoring context (C1 has it, C2/C3 do not) — this is load-bearing for what C1 means; it is a feature of the condition, not a bug to eliminate. I am measuring the effect of breaking that privilege, not isolating it.

• Vendor hidden system prompts — I cannot see Anthropic / Google / OpenAI’s internal pre-prompts; they differ across vendors by design.

• Model version drift — I snapshot IDs at preregistration but vendors can change routing behind a named model. I report the exact IDs and re-run if any vendor announces a change before the F1 table ships.

• Taxonomy contamination — if any reviewer has seen this exact taxonomy in its training or system prompt, it has an advantage. Taxonomy was not published before authoring began; it is published in this article, which means any reviewer touched by this article post-publication is contaminated. Eval runs complete before this article is indexed.

• Grader leakage — graders are blind to condition but not blind to the taxonomy. This is documented and the scoring rubric separately reports category-match vs. mechanism-match to keep the two distinguishable.

Each artifact runs all four conditions. 50 flawed artifacts × 4 conditions = 200 review runs. Plus 10 zero-flaw controls × 4 conditions = 40 abstention runs. Total: 240 review runs.

Preregistered analysis rule. Before any review run executes, I commit publicly to the following decision rule:

• Primary statistic: paired bootstrap of F1 deltas across artifacts (10,000 resamples, 95% CI).

• H₀ survives if the 95% CI for each pairwise delta (C2−C1, C3a−C2, C3b−C2, C3a−C1, C3b−C1) contains zero.

• H₁ supported if C2 > C1 CI excludes zero AND C3_max − C2 CI excludes zero AND C3_max − C2 lower bound is strictly positive where C3_max = max(C3a, C3b).

• H₂ supported if H₁ is supported AND C3_max − C2 lower bound > C2 − C1 upper bound (i.e., the family-effect dominates the session-effect non-overlappingly).

• Inconclusive if any decisive CI width exceeds ±0.10 on F1; in that case I enlarge the corpus and re-run before claiming a result.

Micro-F1 is primary; macro-F1 and cost-adjusted F1 are reported as secondary. Abstention rate on the zero-flaw controls is reported per condition as a separate table.3. Metric

Primary: micro-F1 on flaw detection vs. ground truth. A review “catches” a flaw if it names the flaw category (category-match) OR describes the specific mechanism with enough precision that a human grader marks it as a hit (mechanism-match). Category-match and mechanism-match are reported as separate F1s in addition to the combined score — this keeps taxonomy-pattern-matching distinguishable from independent reasoning. Grading uses two independent graders blind to condition; disagreements go to a third-grader arbitration pass. Inter-rater agreement (Cohen’s κ) is reported alongside the F1 table.

Zero-flaw controls: abstention rate per condition (ideal = 100% no-flaw-reported on the 10 clean artifacts; anything lower is overcalling).

Secondary: precision, recall, cost-adjusted F1, novel-flaw rate (flaws the human graders missed but the LLM identified — these are kept and audited; a portion will likely be added to future ground truth).

4. Token tracking

Total tokens per condition, per run. Reported alongside the F1 table.

Early signal — the cheap cascade, running today (directional, not the table)

The full 240-run experiment is 2 weeks out. But the cross-family cascade is already running — not as the controlled experiment above, but as a working implementation that anyone can fork. I built it, ran it, and I’m publishing the code + numbers alongside this article so you can redline both.

What’s running. A judge-panel cascade skill (public repo, v3.2.0): two cross-family small-fish judges (Gemini-3.1-Flash-Lite + GPT-5.4-nano) run in parallel as the first pass. If they agree with high confidence (≥80), the verdict stands. If they disagree OR confidence is low, one big-fish cross-family tiebreaker (GPT-5.4) fires. Stdlib Python; no SDK dependency; one command to reproduce.

First-batch numbers. Eight seeded-flaw cases, two rubrics (hallucination and flattery), ground truth committed before any LLM saw the artifacts:

MetricValue Accuracy100% (8/8) F1 (fail class)1.000 (P=1.000, R=1.000) Panel agreement rate (small-fish converge)75% Escalation rate (tiebreaker fires)25%

The two escalations fired exactly where a fake-citation case and an ambiguous-range claim split the small-fish panel — which is the cascade behaving as designed rather than the panel failing. No false positives; no false negatives.

What this is, in terms of the harness above. This is a narrower experiment than C1/C2/C3a/C3b — the small-fish panel runs cross-family, but the Part 2 thesis isolated to a single condition (cross-family vs. nothing). It’s the Part 2 claim retested under controlled conditions with committed ground truth and public code. It is NOT the fresh-session-vs-same-session comparison that the main harness above will ship in 2 weeks.

What this is not. Eight cases is a pilot, not a paper. The corpus was authored by the same person who wrote the rubrics — some hand-inherent bias. Single-session per condition, no intra-run variance measured (cf. Rating Roulette, EMNLP 2025 — intra-rater variance is first-order). The 50-case experiment above is the one I’ll stand behind as evidence; this is the one I’ll stand behind as “here is running code, here is a first signal, here is the open harness — fork it and try to break the result.”

Why publish directional numbers. Because the asymmetry is the point. The cost of not running cross-family review — Part 2 already showed — is measured in weeks of downstream rework when a closed-loop same-family review approves a drift that had to be undone later. Publishing directional numbers now, with the caveats above, lets readers run the cascade on their own corpus before the full table lands. Being wrong-in-public beats being confirmation-biased-in-private.

The harness for this pilot is in the same public repo as the 50-case harness above. Both are forkable. Both are run-able from one command.

Forward this to one engineer running LLM evals this quarter — the 240-run harness is forkable before the F1 table drops.

What you can do with this before I publish numbers

Three things, in increasing ambition.

(a) Add one cross-context review to your eval suite this week.

In the eval harnesses I’ve looked at across a dozen agentic-systems teams in the last six months, nearly none run a fresh-session pass on their own outputs — the primary model reviews itself in the same session, and that’s the review. If you add one fresh-session pass — same API key, same model, new session, no authoring history — you add an independent signal. Whether that signal is more or differently reliable than self-review is exactly what this harness is testing. Running it in parallel with current self-review loses you nothing even if H₀ turns out to be true. Recent judge-reliability work suggests intra-rater variance is itself first-order (Haldar & Hockenmaier, EMNLP 2025) — so a second independent pass is defensible on priors even before this harness lands.

(b) Run the harness on your own corpus.

If you build agentic systems, you already have a corpus of 50+ design docs, PR descriptions, architecture memos, or production-readiness reviews. Seed flaws into a held-out 20. Run C1/C2/C3a/C3b. Report F1 internally. The methodology travels.

(c) Bet against me.

If your prior is H₂ (family is the load-bearing variable and fresh-session barely helps), say so publicly. If it’s H₀ (none of this matters), say so. I’ll collect the bets and score them against the F1 table when it ships.

Why the methodology ships first

Every eval post I’ve read in the last six months has the same shape: here are the numbers, here’s the takeaway. That order is backwards when the numbers are the thing being contested.

Methodology published first forces the author to commit to a prediction before the data lands. It lets readers pre-register their own predictions. It rewards being wrong-in-public over being confirmation-biased-in-private.

The Andrew Ng frame — the best AI builders differentiate on eval quality — has a quiet corollary. Eval quality includes eval epistemics. Who ran the eval, in what context, against what prior, with what willingness to publish the unfavorable result.

Numbers without methodology are marketing. Methodology without numbers is scaffolding. I’d rather ship the scaffolding first.

What’s next

• Already public (v3.2.0, today): the cross-family cascade skill + pilot harness — github.com/thewhyman/prompt-engineering-in-action. One-command reproduce.

• ~2 weeks: F1 table + full methodology write-up + the 50-case C1/C2/C3a/C3b harness code on the same public repo.

• Week of 2026-05-12 (Part 4): The Eval Taxonomy Production Systems Don’t Have — the 7–10 categories most eval harnesses under-specify, with an implementation sketch per category.

• Week of 2026-05-12 (Part 5): The Stop Button Nobody Built — intelligence collapse as an architecture problem, not an alignment one.

→ If you’re running an eval harness on agentic systems and want to compare methodology notes before the F1 table ships, I’d genuinely like to talk.

Prior art — the work this harness stands on

Cross-model and judge-reliability research in the last 12 months has sharpened exactly the questions this harness is built to answer. Readers evaluating my methodology should evaluate these alongside it:

• Verga et al., 2024 — Replacing Judges with Juries: Panel-of-LLM-evaluators (arXiv:2404.18796) — multi-model panel evaluation; supportive evidence for panel-level diversity.

• Wataoka et al., 2024 — Self-Preference Bias in LLM-as-Judge (arXiv:2410.21819) — same-family reviewers prefer same-family outputs.

• Li et al., 2025 / ICLR 2026 — Preference Leakage in LLM-as-Judge (arXiv:2502.01534) — training-distribution leakage across judge-candidate pairs.

• Xu et al., ACL 2025 — Does Context Matter? ContextualJudgeBench (paper) — contextual evaluation is itself a hard open problem.

• Huang et al., Findings ACL 2025 — An Empirical Study of LLM-as-a-Judge (paper) — judge generalization and fairness.

• Shi et al., IJCNLP 2025 — Judging the Judges (paper) — position bias as systematic, not noise.

• Haldar & Hockenmaier, EMNLP 2025 — Rating Roulette (paper) — intra-rater variance is a first-class reliability issue; directly load-bearing for the fresh-session hypothesis.

• Guerdan et al., NeurIPS 2025 — Rating Indeterminacy in Human and Model Evaluation (paper) — single gold labels systematically mis-validate judges; complicates any claim that one ground-truth grading pass is authoritative.

• Wang et al., ICLR 2026 — Evaluating Evaluators: Judge Inconsistency and Transitivity Failures (paper) — LLM judges exhibit non-transitive preference orderings; the harness’s paired-bootstrap design is designed to be robust to exactly this failure mode.

A preregistration snapshot (conditions, model IDs, decoding params, analysis rule, corpus commit hash) will ship with the F1 table in ~2 weeks. If you want the preregistration document before runs begin, subscribe and reply; I’ll send it.

#AIReliability #LLMEvaluation #LLMasJudge #EvalDrivenDevelopment #AIEngineering #ModelDiversity #AIAgents #MCP #FrontierAI #AppliedAI #ResponsibleAI #BuildInPublic

The question is: whose assistant is it?

I asked that question at ClawCamp last Friday in front of enterprise infrastructure leaders, indie builders, and a handful of VC partners. The room got quiet in the way rooms get quiet when a question lands on something people have been feeling but haven't said out loud.

Because here's what's actually happening in enterprise AI right now: companies are racing to deploy AI systems for their employees. Copilot for this, Claude for that, Gemini wired into everything. The story they're telling is productivity. The subtext they're not telling is ownership.

Who owns the context your assistant accumulates? Who owns the preferences it learns? Who owns the model of how you think, what you value, what you want from your work?

Right now, the answer is: not you.

The Walled Garden Problem

The AI ecosystem was supposed to be open. It's not.

Claude, OpenAI, Google — they're each building agent harnesses designed to keep you inside their infrastructure. This isn't conspiracy; it's business model. Your context, your history, your trained preferences are the moat. The lock-in is feature, not bug.

For individual users, this is annoying. You switch tools and start over. You have three separate AI "assistants" that don't know about each other, can't share context, and each remember a different version of you.

For enterprise workers, it's more serious. The agent your company provisions learns your work patterns, your communication style, your judgment calls, your private frustrations. Where does that go? Who can see it? What happens when you leave?

The people building the infrastructure for agent deployment — and I was in a room full of them — are starting to ask versions of this question. They're not sure they like the answers.

The Cyborg vs. the Digital Twin

Before I describe what I think the solution is, I want to draw a distinction that I think clarifies almost everything.

There are two visions of what AI at work looks like. They sound similar. They're not.

The Digital Twin is a copy of you — built by your employer, trained on your outputs, owned by the company. It imitates your behavior. It defends your positions in meetings. It produces what you'd produce if you were there. It's you as a resource, not you as a person.

The Cyborg is different. It has your context, yes — but it operates from your interests, not your positions. It's yours. You bring it to work. It represents you in company systems without losing you in the process.

That distinction — interests vs. positions — is borrowed from Roger Fisher and William Ury's "Getting to Yes," arguably the most important negotiation framework of the last fifty years. Their insight: positions are what people say they want. Interests are why they want it. Ego and friction live at the positions layer. Real collaboration happens at the interests layer — when you understand what people actually need, not just what they're asking for.

Your digital twin is trapped at the positions layer. It argues your corner. It defends your turf. It's a very sophisticated echo of your professional ego.

Your cyborg operates at the interests layer. It knows what you actually need from this job, this project, this relationship. And when it meets a company system — or another person's cyborg — it doesn't negotiate. It finds fit.

That's xHumanOS meeting xTeamOS. Your agent going to work inside their infrastructure, representing you without losing you.

The Hard Technical Part

Here's where it gets messy.

Cross-ecosystem agent communication doesn't exist yet.

@anand/career-cyborg needs to handshake with @acme/project-manager. They might be running on different harnesses — different runtimes, different context formats, different memory schemas. Today there's no protocol that makes that possible at an identity level.

LangChain and CrewAI don't solve it. They add abstraction on top of the walled gardens; they don't build bridges between them. What's missing is an addressing layer — a way for one agent to say to another: "Here's who I am. Here's what I'm authorized to share. Here's what I need from you." And for that handshake to happen without either agent having to expose private context or compromise on sovereignty.

What makes this hard isn't the networking. It's the identity and privacy problem underneath it.

When your agent enters company infrastructure, it's bringing context that belongs to you — your career goals, your compensation benchmarks, your honest assessment of the work, your outside interests. None of that should be visible to the company system. But enough shared context has to flow for the collaboration to actually work.

The separation IS the enterprise compliance story. Without it, you get either a privacy violation or a value leak. With it, you get something genuinely new: agents that collaborate at the interests layer while preserving sovereignty at the identity layer.

What I Actually Showed

At ClawCamp, I walked through this conceptually rather than as a live demo.

Not because the architecture doesn't exist — but because the protocol for the handshake itself is still being built, and I wanted to be honest about that. There are people already building cross-ecosystem primitives. What's missing is the identity and sovereignty layer that makes it safe and actually useful. The plumbing is coming. The interests-alignment mechanism is what we're working on.

A few people came up afterward and said some version of: "I've been trying to describe this problem and couldn't. Now I have vocabulary for it."

That's what I wanted. Not to demo a finished thing, but to name the category clearly enough that when someone sees it built, they'll recognize it.

The Political Act Under the Technical One

Here's the thing I kept coming back to during the talk.

Building personal agent sovereignty isn't just a technical problem. It's a political one.

The choice of whether your AI assistant represents you or your employer isn't neutral. It's a labor question. It's a privacy question. It's a question about whether the productivity gains of AI accrue to the people doing the work, or are captured by the organizations deploying the tools.

Companies will provision agents for employees. That's already happening. If your personal context bleeds into the company agent — or vice versa — you get either a privacy violation (company sees what it shouldn't) or a value leak (you put yourself into a system you can't take back when you leave).

The separation between your agent and their infrastructure isn't just good architecture. It's the mechanism that makes this whole category of AI safe to actually use.

Agent ownership rights aren't coming. They're here now as an engineering choice. The question is whether the infrastructure being built encodes them or ignores them.

Where to Start

Ethan Mollick named the frame — co-intelligence. The idea that humans and AI are better as partners than either is alone, and that the right move isn't to resist or be replaced, but to build the partnership.

I've been building the OS underneath it.

The entry point is Co-Dialectic — the personal AI layer I've been building and shipping.

It's not the full sovereignty protocol. It's the starting point: an AI layer that models your interests rather than your employer's outputs, that runs locally where privacy matters, that accumulates context you actually own.

The cross-ecosystem handshake protocol is what comes next. That's the part being built now — the mechanism that lets your cyborg operate inside company infrastructure without losing what makes it yours.

If you were at ClawCamp, you heard this live. If you're reading this here, I want to hear your version of the problem.

What breaks for you when your AI assistant doesn't know who it's working for?

Anand Vallamsetla is building xHumanOS — personal AI that represents you, not your employer. Follow the build at thewhyman.com.

(Try Now: Install prompt - https://github.com/Exponential-OS/prompt-engineering-in-action/releases/tag/v4.1.0)

Most teams are using a top-tier model through an untouched conversation.

Vague prompt in. Confident answer out. Nobody checks the citation. The decision ships. A week later, a stat is wrong, a name is misattributed, a “best practice” turns out to be hallucinated, and the trust the model spent months earning evaporates in one Slack thread.

That gap — between the model’s capability and the conversation surrounding it — is where LLM ROI quietly leaks. **Co-Dialectic v4 is the layer that closes it: cross-family verification underneath every message, mean cost around $0.006 per checked artifact.**

## What Co-Dialectic is, in one sentence

Co-Dialectic is a universal AI conversation layer that sharpens your prompt on the way in, runs cross-family verification on the way out, and catches hallucinations and sycophancy before either reaches you — at near-zero marginal cost.

It is not another model. It sits *beneath* whichever model you already pay for (Claude, GPT, Gemini) and raises the floor of every interaction.

## The strongest claim — cross-family judge cascade

Most LLM verification asks the same model family to grade itself. Same training distribution, same RLHF gradient, same blind spots; the verifier rubber-stamps what the author would have said. Co-Dialectic’s cascade routes every high-stakes artifact through small judges from at least two different model families — Anthropic and OpenAI, OpenAI and Google, whatever you wire up — and only escalates to an expensive tiebreaker when the cheap panel disagrees.

Cost: a realistic stack of Haiku 4.5 + GPT-5.4-mini lands around **~$0.006 per checked artifact**; cheaper-tier (4o-mini + Gemini Flash-Lite) lands under a cent. That’s **10× to 30× cheaper than a naive parallel premium jury** (Opus + GPT-5.4 + Gemini 2.5 Pro running in lockstep), and it catches a strictly bigger class of failures because the disagreement *is* the signal.

This is the primitive no open-source *conversation layer* ships today — LLM eval frameworks exist; a drop-in per-conversation cross-family verifier doesn’t.

## Why v4 matters

Three things actually shipped in v4:

**1. Research-first mode.** Co-Dialectic spawns research sub-agents *before* asking you to act on a question. The default flips: cheap parallel research, then human judgment — instead of human-judgment-first, research-when-forced. Toggle with `co-dialectic research on/off`.

**2. Handoff codification.** At session end, Co-Dialectic scans the conversation for unfinished items, decisions, and lessons; emits structured JSON; the workspace adapter persists where it belongs (GitHub issues, handoff doc, whatever the workspace defines). No more re-explaining unfinished work to the next session.

**3. Cascade routing.** Verification primitives — prompt rewrite, persona detection, sycophancy scan, hallucination pre-flight — route to the smallest model that can handle the job: Haiku 4.5, GPT-5.4-mini, Gemini 2.5 Flash, plus local DeepSeek-R1-Distill-Qwen-7B / Ministral 3 / Phi-4-mini when an Ollama runtime is wired up. The expensive model only fires when stakes warrant it.

The architecture these features compose toward — **bidirectional standalone** (Co-Dialectic works alone, xOS works alone, either composes when both are present) and the cross-family judge cascade above — that’s the strategic frame v4 is filling out, not a single-version delivery.

## The four primitives, explained

**Prompt sharpening.** You type “help me write a launch announcement.” Co-Dialectic rewrites it to: “draft a 250-word launch post for technical leaders, lead with the pain of confidently-wrong LLM output, end with one concrete CTA — open question or specific link?” You accept, edit, or reject before it ships. The sharpened prompt is the product. The model just executes it well.

**Persona system.** Co-Dialectic auto-detects domain — code, product, design, career, writing, debugging, positioning, data, mindset, productivity — and applies a top-0.001%-caliber lens. Jeff Dean-caliber for systems architecture. Shreyas Doshi-caliber for product strategy. Jony Ive-caliber for design. Reid Hoffman-caliber for career strategy. George Orwell-caliber for prose. Linus Torvalds-caliber for debugging. Steve Jobs-caliber for positioning. Nate Silver-caliber for data. Tim Storey-caliber for mindset. Tim Ferriss-caliber for productivity systems. Multi-domain tasks get fused lenses automatically. The product never speaks as the named person, never claims their endorsement, never trains on their work — *caliber* is a comparative quality standard, the way “Hemingway-caliber prose” describes the bar, not the author. Personas are lenses, not delegates; the output is still yours.

**Hallucination detector.** Two stages. Pre-flight: classifies risk surface (factual / quantitative / citation / temporal / proprietary) and conditionally requires grounding sources before the prompt ships. Post-flight: scores every claim against canonical-source criteria and flags high-risk claims before you act. This is the primitive that catches the failure mode that destroys reputations — the confident citation that doesn’t exist.

**Calibration auditor.** Passive scanner across every Co-Dialectic-mediated response. Flags sycophancy markers — “Great question!”, “You’re absolutely right!”, “Excellent insight!” — and engagement-maximizing filler. Flattery degrades your critical filter. The auditor surfaces flagged content as a one-line summary before the response renders. Anti-bubble by construction.

## Three users it’s built for

**Solo professionals.** Consultants, analysts, founders, writers, lawyers, researchers. You already pay for one LLM subscription. Co-Dialectic makes that subscription land more reliable answers on the same daily volume — every prompt sharpened on the way in, every response risk-scored on the way out. You ship fewer wrong answers; your clients trust you more.

**Engineering teams shipping LLMs in production.** Copilots, agents, RAG pipelines, classifiers — anything where a verification layer must be open-source, vendor-neutral, and not couple your reliability story to one provider’s eval infrastructure. Co-Dialectic drops into any pipeline; the cross-family cascade catches what single-vendor verification misses at a fraction of full-jury cost.

**High-stakes researchers and advisors.** Investment analysts, policy researchers, medical reviewers, legal advisors, academic researchers. One bad source past the LLM’s confidence layer poisons a memo. Co-Dialectic’s hallucination detector and calibration auditor are the two highest-leverage primitives in this segment.

## Cost discipline (because this is the question I always get)

- Cross-family review with a **flagship-cheap stack** (Haiku 4.5 + GPT-5.4-mini): **~$0.006–$0.008 mean per artifact** at typical sizes. Drop to **prompt-cached + cheaper tier** (4o-mini + Gemini Flash-Lite): **under a cent.**

- Versus a naive parallel premium jury (Opus + GPT-5.4 + Gemini 2.5 Pro): **~10×–30× cheaper depending on stack choice.**

- Local fish-school primitives (rewrite, persona, sycophancy scan, hallucination pre-flight) run on whichever models you have available via Ollama; near-zero marginal cost when wired up, cheap-API fallback when not.

- The expensive model only fires when the cheap cascade disagrees and a tiebreaker is genuinely needed.

If you’re spending more than a couple cents per verified artifact, Co-Dialectic will make the bill smaller, not larger.

## What’s not in v4 yet (intentional)

- A hosted backend. There isn’t one. There won’t be one in the open-source tier.

- A vendor account. Co-Dialectic runs against your existing subscriptions. We never see your prompts.

- Feature gating against the open-source tier. Every primitive listed above ships in AGPL-3.0. The premium tier (xOS plug-in family) adds capabilities for T3-T4 stakes; it does not unlock existing ones.

## How to try it

Install instructions live in the project README (link in the comments). Open any session, type any vague prompt, and notice the difference in the same conversation.

## The deeper bet

The highest-leverage intervention in AI-assisted work is not a better model. It’s a better conversational substrate. Co-Dialectic is that substrate. v4 is the version where it composes cleanly with everything you already use, runs at sub-cent verification cost, and ships open-source without compromise.

If your team is paying for the model and getting half the answer, the gap is the conversation. Close it.

---

*Co-Dialectic v4 is open-source under AGPL-3.0. Repository, docs, and the issue tracker live -

https://github.com/Exponential-OS/prompt-engineering-in-action/releases/tag/v4.1.0

*If you ship LLM-powered work to anyone who matters, I’d love to hear what catches in your first session — drop a note.

The OpenAI API call is 10 lines of code.

In Part 1, I argued the other 95% is guardrails, evals, edge cases, and modularity. One of those ten decisions — Decision 5 — said:

> *"A naive 'second opinion' LLM makes the same mistakes as the first — same training, same context."*

That was directionally right. I also badly underestimated how far it goes.

Over the last two weeks, while working on patent architecture for a separate AI project, I ran an internal trajectory review on roughly three hours of dense design work. I used three reviewer personas — all running on the same frontier model. They approved the direction. I was about to ship.

Then I ran the same review on **a different model family** — the cheaper one. A Gemini-2.5-Flash pass caught a category of drift that all three same-family reviewers had rationalized. When I escalated to GPT-5 as a tiebreaker, it independently converged on the same class of issues Flash had named.

(Worth saying out loud: I changed more than just the model family between those runs — different session, different prompt framing, different context packaging. So I'm treating this as a strong hint, not a controlled experiment. Part 3 is the controlled version.)

Both external reviewers returned a **NO-ship verdict**, with overlapping dealbreakers. The same-family reviewers would have let me file.

That review cost me 45 minutes. Filing the patent would have cost me a lot more.

Here are the five things I got wrong about LLM reviewers — and what I now believe is the right architecture.

---

### Wrong #1: "Different information" is the differentiator

**What I thought:** Decision 5 in Part 1 solved this. Give the QA agent different inputs (patient record + primary determination + deterministic engine result). Problem fixed.

**What's actually true:** Different information is *necessary, not sufficient*. Same-family models likely share more correlated failure modes than cross-family models do — overlapping pretraining corpora, related post-training recipes, and shared RLHF norms all push them toward correlated blind spots. Different inputs don't cancel that.

**The sharper Decision 5:** Not "different information." **Different model family** (as a practical proxy for different training distribution). Your QA reviewer should come from a different lineage than your primary — Claude reviewing Gemini, GPT-5 auditing Claude, Mistral checking OpenAI. Family diversity is a useful hedge against correlated bias — an engineering heuristic, not a proven theorem. (*Caveat earned the hard way: "family" is not identical to "training distribution." Different vendors still share internet-scale pretraining corpora and RLHF norms, and same-family variants can diverge materially. "Family" is the practical proxy, not a guarantee.*)

Research anchors:
- Verga et al., *"Replacing Judges with Juries"* (2024) — a panel of smaller, diverse judges outperforms a single GPT-4 reviewer while being ~7x cheaper. Supportive evidence for panel-level diversity (PoLL does not isolate family diversity as the sole causal variable).
- Self-Preference Bias in LLM-as-a-Judge (OpenReview, 2024-25) — LLM judges exhibit self-preference bias, favoring outputs familiar to them; related work suggests family similarity can worsen the effect.
- Preference Leakage (ICLR 2026) — primarily about contamination between synthetic-data generators and judges, plus bias toward related student models. Adjacent evidence for why same-lineage judges are structurally suspect, not a direct proof of the generic same-family-reviewer claim.

---

### Wrong #2: More reviewers = linearly better

**What I thought:** Reviewers scale linearly. One is some-goodness, two is twice-as-good, etc.

**What's actually true:** The return curve is sharply front-loaded.

- **Zero → one external reviewer** is often the biggest marginal gain in practice. You go from "self-review — a closed loop" to "external signal exists." That's a structural change, not just a quantitative one. (External reviewers can still share context, rubric, or failure modes — "external" is not magic, it's just the first real gap that lets new information in.) Self-review inside the same model and same session is a well-known weak baseline; I'll publish the F1 numbers and full methodology in Part 3.
- **One → two** is a real but ordinary improvement. Useful. Not categorical.
- **Two → three** is diminishing returns unless you also add a new *axis* of diversity (new family, new modality, new role).

**The implication:** If you're cost-constrained, spend your budget on making the first external reviewer exist. Don't stack three same-family reviewers and call it robust. You have one reviewer and a hall of mirrors.

---

### Wrong #3: The reviewer has to be as smart as the author

**What I thought:** Frontier author → frontier reviewer. Anything less is a downgrade.

**What's actually true:** **Cheap-diverse can beat expensive-same-family — and in my case this week, it did.**

Concretely: the author model was a Claude-Opus-class frontier model. The reviewer that caught the drift was Gemini-2.5-Flash. At published API prices that's roughly a 25-50x cost gap per token for my mix — not a 100x gap; I had that number wrong in my head. (Gemini 2.5 Flash is $0.30/$2.50 per 1M in/out tokens; Claude Opus 4.1 is $15/$75; GPT-5.4 sits between. Full pricing: [OpenAI](https://openai.com/api/pricing/), [Google](https://ai.google.dev/gemini-api/docs/pricing), [Anthropic](https://docs.anthropic.com/en/docs/about-claude/pricing).) GPT-5 later *confirmed* the finding independently. The expensive same-family reviewer approved the direction.

Why this works when it works: the small model's lineage doesn't share the author's correlated bias, so it carries information the author can't generate internally. Sharpness isn't always the bottleneck; *independence* can be.

Caveat: one anecdote plus PoLL isn't enough to claim this is generally true. Treat it as a live hypothesis worth testing in your own eval harness, not a universal law.

This is the PoLL intuition: a jury of weaker, diverse judges can beat a single stronger judge — even when each juror is individually weaker.

---

### Wrong #4: Parallel juries are the default shape

**What I thought:** Spawn N diverse reviewers in parallel, aggregate, done.

**What's actually true:** Parallel juries are expensive. Cascade-then-jury is, in my experience, a better default — and there's a supporting body of cost-aware-cascade literature to draw from, even though none of it proves the specific cross-family-reviewer architecture I'm arguing for.

Adjacent research worth reading:
- **FrugalGPT** (Chen/Zaharia/Zou, 2023): sequence models cheap→expensive, escalate only on low confidence. 30-98% cost savings on the benchmarks they tested.
- **Cascade Routing** (Dekoninck et al., ICML 2025): combines routing + cascading — competitive with or better than either alone on their evaluations.
- **CascadeDebate** (2026): inserts a small-model ensemble at each escalation boundary; matches larger-model Pareto frontiers at a fraction of the tokens (note: their ensembles are same-base-model, not cross-family).

None of these papers is about cross-family reviewer architecture specifically. I'm extrapolating — cascades work on cost, family diversity works on independence, combining them is an engineering bet, not a proven theorem.

**The architecture I'm running:** Run the cheap cross-family reviewer first (async, background, near-free). If it flags uncertainty or disagrees with the author, *then* escalate to an expensive cross-family reviewer. If both flag the same issue — stop and fix it before any further work.

Today's incident was accidentally this exact shape: Flash ran first (one pass, cheap), GPT-5 confirmed (one pass, more expensive). Two passes caught what three same-family passes had let through.

---

### Wrong #5: This is an optimization

**What I thought:** Cross-family review is a nice-to-have. Good when you have time.

**What's actually true:** In my own practice, I've promoted it to an operating rule, not an optimization. Shipping a significant AI-generated artifact without one increasingly feels the way shipping untested code feels: possible, occasionally fine, and not a risk I want to take on load-bearing work.

The rule I now run:

> *No significant artifact — patent filing, architecture decision, production deploy, published claim — leaves my desk without independent review from a different model family. Same persona on the same underlying model is weaker than it looks: same-family models tend to share correlated failure modes.*

I'm calling this a rule, not a theorem. The asymmetry is what keeps me honest: when the review catches a real issue, the cost of being wrong is often weeks of downstream work; the cost of running the check is minutes.

---

### The meta-lesson: self-review is a closed loop

Every frontier model — Claude, GPT-5, Gemini, Mistral — is trained to be helpful, coherent, and internally consistent. That same training can make it a weaker auditor of *itself*. Not because any individual model is weak, but because the objective that makes it strong as an author is often the wrong objective for self-critique.

Andrew Ng has been arguing publicly on DeepLearning.AI that disciplined evals and error analysis are among the biggest predictors of how rapidly a team makes progress building an AI agent ([his recent post on this](https://www.linkedin.com/posts/andrewyng_deepseek-cuts-inference-costs-openai-tightens-activity-7384633283554447360-sVXe) — paraphrased here; the specific wording is his, the framing is mine). I think he's right. The corollary I'd add: the thing separating good eval practice from best-in-class is **who's allowed to run the eval.**

If the answer is "only models from the same family as the author," the eval is much weaker than it looks.

**Part 3 (coming): Cross-Context Review — testing whether even the same model in a fresh session outperforms self-review in the same session.** I'll publish the eval-harness methodology and F1 results next week.

→ If you're building eval infrastructure for agentic systems and this resonates, I'd love to compare notes.

#AIReliability #LLMEvaluation #LLMasJudge #AIEngineering #EvalDrivenDevelopment #ModelDiversity #AIAgents #MCP #FrontierAI #AppliedAI #ResponsibleAI #BuildInPublic

Now you can choose.

Four sections. Subscribe to what matters to you:

🤖 AI & Prompting — Practical techniques, prompt engineering, and human-AI partnership. If you’re here to get better at working with AI, this is your section.

🔧 Under the Hood — The engineering behind things that work. Architecture patterns, system design, technical deep-dives. For builders who want to know why, not just that.

⛓️ Blockchain — Where technology meets trust. Same great content, same community. Nothing changes here.

📡 Signal — Tools, books, and takes worth your time. No sponsorships. No affiliate links. Just things that actually changed how I think or work.

You’re currently subscribed to everything. That won’t change unless you want it to. Visit your subscription settings to pick specific sections — or keep getting it all.

One ask: if you know someone who’d care about one of these sections specifically, forward this to them. The best growth comes from people who chose to be here.

— The Why Man

P.S. — V2 of Co-Dialectic just shipped. If you use AI at all, the AI & Prompting section is where that story lives.

The moment that changed everything

I’ve taught AI and machine learning to over 1,500 Fortune 500 executives across 16 cohorts at UC Berkeley. The first time, I was excited — sharing fire. By the sixth cohort, I was saying “80% of jobs will be replaced” and feeling the room go cold.

By the tenth cohort, something happened that no classroom could prepare me for. My son — 8 years old — walked into my home office during a 7am teaching session. He just wanted to say good morning.

I looked at him and the only thought I had was: his school is preparing him for today’s world. By the time he grows up, everything will be different. He is going to be in trouble.

That fear launched 6,000 hours of research. Movies, books, conferences, academic papers, podcasts. All organized around two questions:

What should I do to stay ahead? And what should I teach my son?

The teachers

Each one moved me one step along the arc from fear to partnership.

Yuval Noah Harari (21 Lessons for the 21st Century) painted the darkest scenario: in 50 years, there may be two human species — one with augmented biological capabilities, and a “useless class” left behind. I couldn’t sleep after reading that.

Ray Kurzweil (The Singularity Is Nearer) was the optimist. Our minds will have cloud extensions. Brain-computer interfaces. Digital immortality. It sounded aspirational — but ungrounded. Hope without a bridge.

Mo Gawdat (Scary Smart) was the first voice that calmed me. His advice: “Be a good parent of AI.” Treat it like you would a child that will eventually surpass you — with love, guidance, and boundaries. I extended his thought: be nice to yourself first; it will automatically make you be nice to others. Including the AI.

Ethan Mollick (Co-Intelligence) gave me hope with a framework. Not replacement. Not fear. Partnership. Both sides teach. Both sides learn. The human brings judgment, values, lived experience. The AI brings tireless execution, pattern recognition, perfect memory. Neither replaces the other. Together, they are wiser than either alone.

That was the moment I stopped being scared and started building.

Install it - One Click

Co-Dialectic on GitHub — free, open-source, works with any AI.

One-liner for Claude Code users:

curl -fsSL https://raw.githubusercontent.com/thewhyman/prompt-engineering-in-action/main/install.sh | bash

Or just copy SKILL.md and paste it into your AI’s custom instructions. 30 seconds. Five systems. Zero configuration.

The language bridge

In Sapiens, Harari identifies the superpower that made Homo sapiens dominant: language. Not just communication — every species communicates. Language enabled humans to believe in shared stories — religion, nations, money, human rights — and those shared stories enabled strangers to cooperate at scale. Every institution that outgrew a tribe was built on language.

We’re at another language moment. “Prompt engineering” teaches humans to speak the language of machines. But that’s one-directional — like learning a foreign tongue by memorizing phrases. The endgame is bidirectional: machines must also learn to speak YOUR language — your style, your values, your vocabulary, your reasoning patterns — until you stop noticing the translation.

I built a tool that teaches both sides simultaneously. I call it Co-Dialectic.

Why “dialectic” and not “Socratic”

Socratic prompting just went viral. Instagram, X, LinkedIn — everyone sharing the same “leaked” technique: ask questions instead of giving commands.

It works. But history tells us it’s step one.

Socrates asked questions to reveal what the student already knew. One direction: teacher → student. His student Plato took it further. In dialectic, both sides refine each other’s thinking through structured back-and-forth. Neither side “wins.” Both sides learn. What emerges — the synthesis — exceeds what either started with.

The viral posts rediscovered Socrates. Co-Dialectic implements Plato.

What it does

You paste one text file into your AI’s custom instructions. Five systems activate automatically:

The right expert shows up. Ask about code and a Software Architect appears. Talk about feeling overwhelmed and a Life Coach responds. You always know who’s thinking and how deep.

Every prompt gets coached. You type “summarize this document.” The AI suggests: “What are the 3 key tensions — and what does the author assume that might be wrong?” Then it waits for your choice. Over days, the coaching appears less — because you’ve gotten better.

Context never silently degrades. Every AI has a memory limit. Chat long enough and it quietly forgets earlier decisions. Co-Dialectic makes this visible and generates a handoff summary before quality drops.

Every correction becomes permanent. Say “when I say ‘show me,’ I mean images — not text.” The AI captures the broad principle: always use the richest format. Correct once. Benefit forever.

The AI teaches you back. It names techniques you’re already using — Socratic prompting, few-shot by example, chain-of-thought steering — through your own conversation, not a textbook.

Your irreplaceable strengths, surfaced. When something needs YOUR judgment — your relationships, your values, your lived experience — the AI says so. When something is pure pattern-matching, it says “let me handle this.” Over time, you learn what to keep and what to delegate.

The flywheel

Day 1: Prompt Quality: 45% clear — You correct the AI. It saves broad principles.

Day 3: Prompt Quality: 62% clear — The AI applies lessons automatically. Fewer corrections.

Day 7: Prompt Quality: 78% clear — The AI coaches your prompts. You learn patterns you never saw.

Day 10: Prompt Quality: 91% clear — You anticipate each other. What took 10 exchanges now takes 1.

1% daily improvement compounds to 37x in a year. You feel it in the first week.

What I built from the fear

That morning when my son walked in, I started two things.

thewhykid.com — to expose him to technology early enough that he can build on top of it, whatever he chooses to do. The future belongs to people who treat AI as a tool, not a threat.

Co-Dialectic — the tool I wish I’d had when I was afraid. It doesn’t just make your AI better. It reminds you of what makes YOU irreplaceable. Your judgment. Your relationships. Your creativity. Your ability to care about things that matter.

The people learning prompt engineering right now — many of them are scared. They’re learning because they want to stay ahead of the chopping block. I know, because I was one of them.

Co-Dialectic is for them. It’s the coach that says: “Yes, learn the machine’s language. AND remember — you bring something the machine never will.”

Install it

Co-Dialectic on GitHub — free, open-source, works with any AI.

One-liner for Claude Code users:

curl -fsSL https://raw.githubusercontent.com/thewhyman/prompt-engineering-in-action/main/install.sh | bash

Or just copy SKILL.md and paste it into your AI’s custom instructions. 30 seconds. Five systems. Zero configuration.

Coming soon in this series: Deep Personalization (AI that learns your story without leaking PII) and AI Career Coach (navigate the reshaping economy — which skills to learn, when to move, how to position yourself).

Subscribe to Technology, Education and Policy to get notified when they launch.

Anand Vallamsetla has taught AI/ML to 1,500+ executives at UC Berkeley across 16 cohorts. He’s a senior engineering leader with 26 years of experience, ex-Google. He started thewhykid.com because his 8-year-old walked into the room during class and he got scared. Co-Dialectic is what he built from the other side of that fear. Connect on LinkedIn.

This is made possible by non-KYC exchanges like “FixedFloat,” which allows rogue actors to get funds to publish contracts, steal money, and withdraw without any consequences!

This post is about 1 specific phishing attack to provide action items you can take to not fall for it and propose some product updates to Metamask, Ethereum, and possibly a new KYC service (more to come later)!

About the Drainer as a Service (DaaS)

Source Of the Attack:

Email to Gmail (See below)

Attack Name:

Angle Drainer

Attack Form:

The url shows as unstoppabledomans com, but the actual URL is https://xn--unstoppabledomans-rvb com.

Action:

Once you connect your wallet to the site, it will ask you repeatedly for permissions; once you approve, it will drain all of your funds across all EVMs - BSC, ARB, Polygon, Avalanche, Optimism, FTM, Celo, Cronos, and Base. This is not only ETH but anything on top of ETH, even if it is staked.

Rogue Contract:

https://etherscan.io/address/0xf7e729e00c297d452c56a0dca163a93bb2fe6f87

This is replicated 4 more times, so there are other contract addresses that you should be careful about.

Funding Actor:

https://etherscan.io/address/0xf7e729e00c297d452c56a0dca163a93bb2fe6f87

Exchange Used for Funding:

FixedFloat

Affiliate Address:

0x4455f284c3bB9E074305795c260a111c8F709858 is the affiliate address (the person who "rents" the drainer) (Affiliate gets 85%)

Operator Address:
0xa3aa460C12713A000a33893b024D95db80945a2F is the operator (the person who "owns" the drainer) (Operator keeps 15%)

Actions You Can Take to Protect

1. Always read the email headers. If the from address is suspicious, DELETE the email - don’t click on anything & most notably, report it as phishing (Gmail or email service provider AI may label it as phishing if many people report it) so that other people will benefit from your action!

2. Always look at the URL; if it is not something you think is legitimate, then close that tab immediately.

3. When you connect your Metamask or other wallet, the wallet will prompt you for permissions. READ EVERY detail on the popup before clicking approve. If you don’t understand, reject. Remember that malware scripts will repeatedly ask for approval.

4. If you lost your funds, I empathize with you. However, you can take some actions, like reporting to authorities so that others don’t fall victim. The chances of recovering funds are meager.

   1. FBI IC3 Report https://www.ic3.gov/Home/ComplaintChoice

Future Proofing

1. Install https://revoke.cash/exploits chrome extension

2. https://revoke.cash/exploits - Revoke permissions and signatures for the contracts that you don’t trust

3. Improve products like Metamask, Ethereum, and a new KYC service. I have a lot of ideas for using crowdsourcing. to stop the attacks when they are small. More to come in the next post

If you would like updates and want to learn more about my ideas. Please subscribe to the blog.

Share Technology, Education and Policy (TEP) Newsletter

However, I came across this app at 1 AM in the morning, and it seemed interesting. So, I thought I would try. I paid $30 or so for it, and it said 100% money-back guarantee, etc.

It is a personal assistant. I couldn’t stop using it till 3 AM and felt the money was already paid for.

I did the following by filling in a few questions like ChatGPT, and it took care of the rest:

1. Deleted All Data Broker Data

2. Submitted Nuclear SPAM removal request with top 12 email campaign brokers

3. Added to Do Not Call List

4. Return request for Amazon that has passed the return date. It created a letter, AND IT MAILED it. Mindboggling!

5. Signup for FREE Crypto Airdrops

6. Filed unclaimed property request

7. For fun, I uploaded a doc to mail for FREE.

8. For fun, I requested an FBI profile about me.

9. For fun, I requested a credit report, even though I was getting this from other sources.

You can do much more - Online Notary, Surf free trials, beat parking tickets, sue robocalls for cash …

Use the following code to join so WE can get some FREE stuff!

https://thewhy.li/DoNotPayCode

Very thorough and easy to follow. Dumbs down tech so much that it covers the first principles that you can build upon.

You will learn about the WHY? of this technology that can help you with your job, entrepreneurship and investments!

Time worth spending! Enjoy and share this page….

MIT Blockchain and Money

This really speaks to people with high cognitive abilities that need scientific evidence for everything that they do.

This book is so needed in today’s world where 60% of the population is experiencing some form of depression from isolation and feeling lost.

Spirituality can be passed down to generations through genes (29%). 71% is in your hands (nurture). Go change yourself!

Blinkist Summary (Text/Audio) - Awakened Brain (Referral link to get discount)

Thrift Books - Awakened Brain

Please leave you comments about what you liked or didn’t like.