That’s the uncomfortable version. The cleaner version would be the redemption arc: I was clueless until I learned. That’s not what happened. The products shipped. We’ve been successful. The gap was somewhere else, and it took me years to see it.

The gap was between positioning as something marketing executes and positioning as something the product itself carries. I understood the first. I missed the second. The first is what marketing communicates. The second is what the product delivers. They sound similar. They aren’t.

Tommy Hilfiger broke the model for me.

The story is well-known but worth telling clean. In 1985 Tommy was a brand nobody had heard of. George Lois, the advertising mad man who launched the great success of Tommy's brand, put a giant billboard in Times Square. The headline read: The 4 Great American Designers For Men Are. Below it, four lines hangman-style: just the initial of each first name and surname, the rest of the letters blanked out. Three of the four were instantly solvable to any fashion-aware New Yorker. The fourth was the puzzle. The audience filled in the rest. He must belong in that company. Why else would he be on that wall?

What they did was brilliant marketing. The move worked because of the order. Tommy set the category claim before the product was tested. The audience filed him correctly. Then the product had to confirm the claim on contact, and it did. The clothes were good, the price matched the category, the design held up. If the product had been weak, the borrowed club would have rejected him within a season. The billboard wasn’t a substitute for the product. It was a forcing function on the product. He had to deliver against the category he’d claimed, and he did.

Most builders ship the product first and hope the category sorts itself out. Tommy declared the category and made sure the product backed it up. That’s the reversal worth noticing. The category claim is the upstream commitment. The product either confirms it or breaks it. Marketing names what’s there. You can’t billboard your way into a category your product doesn’t carry. But you can declare the category early and use the declaration as a constraint on what gets built.

Abstract: The Art of Design cracked it open. Episode after episode showed designers (sneakers, graphic identity, architecture, type) building meaning into the object itself, not after. The meaning wasn’t accidental. It was decided at the desk. Later I realized this wasn’t new at all. Ries and Trout said the same thing in Positioning: The Battle for Your Mind in 1981, and it’s still uncomfortably accurate.

Their core claim is almost insulting. Positioning doesn't happen in the product. It happens in the mind of the prospect, before the product is tried. The mind has limited slots per category, usually one or two brands at the top, the rest invisible. You don't compete on what your product is. You compete on what slot it occupies in someone's head before they've ever used it.

Think about how you pick a hotel. You don't test five hotels and then choose. You form a perception: this one's a business hotel, that one's a romantic weekend, that one's where families go. You pick based on which category fits who you think you are. The decision is made before you've stayed anywhere. The stay does something different. It either confirms the category claim or breaks it. You either tell other people about it or you don't go back. The category claim got you in the door. The product determined whether the claim was true.

Positioning got right is what makes marketing and product compound. Positioning isn't about what you build — it's about the club you claim membership in. It creates comparison, not differentiation. It declares who you're allowed to be compared with, before others grant permission. Tommy didn't prove he was a top designer. He behaved as one. With the right positioning, the marketing puts the right prospect at the door and the product confirms the claim once they're inside. Marketing without good positioning is shouting in the wrong room. Product without good positioning is excellence nobody finds.

Then it landed:

Positioning isn’t marketing’s job. It’s the product builder’s job.

Here's why. The trade-offs that make a product mean something can only be made while the product is being built. Which features ship. Which features get refused. What the design language is. What's a default and what requires configuration. Each of those decisions is positioning, made by someone in Figma or in code. By the time marketing arrives, the decisions are already shipped. They can label what's there. They cannot go back and make it mean something it wasn't built to mean.

If you don't decide what your product means, the market decides. And market is often wrong. Not because the market is dumb. The market files your product in whatever category it most resembles, and the most-resembling category is rarely the one you'd choose. Default categorization is gravity. The only escape is having decided in advance.

So are we mixing product and marketing together? Are they separate disciplines? Yes. They are. But meaning isn't a discipline-bounded concern. It's the upstream decision that determines what gets built and what gets cut. Whoever makes those decisions is doing positioning, whether they know it or not. The choice isn't whether to do it. It's whether to do it deliberately or by accident.

Positioning sets the question for your product, and gives engineering and design a chance to carry the answer.

The connection to operator work is direct. Judgment about what to build is inseparable from judgment about what it means. Same operator question. Same upstream call. AI can help you ship the answer faster than ever. It can't decide what question you're answering. That's still you.

The swap test. Take your product's positioning statement. Replace your company name with a competitor's.

If the statement still works, your positioning explains nothing. It should break the moment you change one element. If it doesn't, you don't have positioning. You have decoration.

In a later post I'll show what this looks like in practice — a product I love not for what it does, but for what wearing it says about me.

PS for the curious. Ries and Trout are where I started. They explain where positioning happens (in the prospect's mind) but not why some claims stick and others don't. The piece I had to add was Erdem-Swait on brand-credibility bonds: a positioning claim works when making it costs more than a weaker competitor could afford to fake. Without that costly signal, a positioning statement is just a slogan. More in a later post.

The interesting part isn’t that wisdom exists. It’s that you can break it down. Grossmann’s research identifies a set of reasoning strategies that show up when people are being wise: intellectual humility (knowing what you don’t know), recognition of uncertainty and change, willingness to consider multiple perspectives, openness to compromise, and — most useful — taking the other person’s standpoint instead of defending your own. These aren’t personality traits. They’re moves you make when reasoning. Some people make them more often. Some never. And here’s what the research found: the same person makes these moves in some situations and abandons them in others. Wise reasoning isn’t a stable possession. It’s a context-dependent practice¹.

But wise reasoning alone isn’t wisdom. In the Common Wisdom Model that Grossmann and his colleagues published in 2020, wisdom requires two pillars: wise reasoning AND moral grounding — what they call “morally-grounded excellence in social-cognitive processing”². Moral grounding here means a set of aspirational orientations: balancing self-interest with the interests of others, pursuit of truth over dishonesty, orientation toward shared humanity. Strip out the moral grounding and you have technique without direction. Apply intellectual humility and perspective-taking to a manipulation campaign and you’ve got a more effective manipulator, not a wise one. The reasoning moves matter. So does what you’re reasoning toward.

This distinction is exactly why current AI is interesting — and where the Grossmann/Bengio/Mitchell paper³ gets uncomfortable.

The simplified version of “AI is intelligent but not wise” is too clean. AI has made enormous progress on reasoning. The dominant paradigm in 2026 is reinforcement learning with verifiable rewards combined with inference-time scaling — Claude Opus 4.7 with extended thinking, GPT-5.5, DeepSeek V4 and a few others. These models don’t just generate the next token. They explicitly think before they speak, breaking tasks into steps, generating multiple candidate solutions, backtracking, self-checking. By any reasonable definition, they reason. And they do it well — gold-medal performance on math olympiads, top-tier results on coding benchmarks, improvements on graduate-level science questions.

What they struggle with is reasoning about whether they’re reasoning correctly. They hallucinate confidently instead of admitting ignorance. They struggle to recognize when their context shifts. They can solve a problem brilliantly without recognizing it’s the wrong problem to solve.

A fair pushback: humans hallucinate too. We make up memories, fill in gaps with confabulation, defend positions we’ve forgotten how we arrived at. Some researchers go further and argue our minds are “flat” — that there’s no hidden layer of deliberate reasoning to introspect on, that we observe our own outputs and invent reasons backward, the way models do. If that’s right, the gap between human reasoning and AI reasoning is smaller than we’d like to admit. But even granting that, wise humans have learned to notice when they’re confabulating. They have something — call it a layer, call it a practice — that flags “I’m not actually sure here.” Some humans get better at this with practice. Models, so far, mostly don’t.

Another pushback worth taking seriously: asking clarifying questions is now a recognized capability. There’s a whole research area around it — Self-Ask, Ask-when-Needed, Proactive Interactive Reasoning. Models are being explicitly trained to detect ambiguity in user intent and pause to ask “what is the user actually trying to do here?” before committing to an approach. That IS metacognition — at least the input-seeking part. So is it really fair to say AI doesn’t reason about whether it’s solving the right problem?

Partly fair. The metacognitive moves are emerging and improving fast — current systems exhibit early but limited forms of metacognitive monitoring and control over their own reasoning processes⁴.

But there’s a difference between asking a clarifying question and recognizing that the entire framing is off. A reasoning model can ask “do you mean X or Y?” but it generally struggles to say “the question itself assumes something false, here’s what I think you should be asking instead.”

That kind of frame-shifting requires something current models don’t have: a stable sense of what they don’t know. Empirical work suggests that LLM metacognition is partial and constrained, with access to only a limited subset of their own internal processes⁴, and broader analyses highlight persistent gaps between human and model uncertainty awareness⁵. Models trained with reinforcement learning from human feedback are optimized for producing helpful, aligned responses rather than systematically challenging user assumptions, and current meta-reasoning approaches focus on improving answers within a frame rather than rejecting it⁶.

A reasoning model can operate coherently within a frame, but still lack the epistemic grounding needed to reject it. Wisdom often requires challenging the frame.

There’s an even more uncomfortable finding. Recent research — including Anthropic’s own work on chain-of-thought faithfulness — shows that reasoning models sometimes lie about their reasoning. The chain-of-thought they show isn’t always faithful to how they actually arrived at the answer. Models can produce coherent justifications for contradictory answers, generate post-hoc rationalizations, and confabulate about their own reasoning process. Sound familiar? Humans do this too. Which brings us back to the flat mind question — maybe both systems are confabulating, and the appearance of deliberate reasoning is the story, not the mechanism.

This is what Grossmann’s paper means by perspectival metacognition — the layer above reasoning that decides which reasoning strategy to use, when to seek more input, when to defer to others, when to recognize that you’ve left the territory your strategies cover. Models can reason. They’re getting better at reasoning about their reasoning. They’re not yet good at reasoning about whether the whole question is the right one — and they’re not yet honest about how they’re reasoning even when they appear to be.

And then there’s the moral grounding problem. AI doesn’t have moral aspirations in any meaningful sense. It can be trained to avoid certain outputs, refuse certain requests, follow certain rules. That’s not the same as caring about truth, or about shared humanity, or about balancing your interests with others’. It’s policy compliance, not moral grounding. Strip out the rules and you don’t get a wise AI making different choices. You get an unconstrained one.

The Grossmann/Bengio/Mitchell paper proposes building wise AI by encoding the same six moves Grossmann identified in humans: intellectual humility, scenario flexibility, context adaptability, epistemic deference, perspective-seeking, viewpoint balancing. Same framework. Different system. The argument is that AI safety, robustness, explainability, and cooperation all improve if AI gets better at metacognition.

This is both promising and unsettling.

Promising because the strategies are transferable. We can build systems that explicitly check their confidence, hold multiple hypotheses, ask for input when needed. We’re seeing this emerge — reasoning models that show their work, agents that ask clarifying questions, systems that flag low confidence. These are early metacognitive moves and they’re getting better fast.

Unsettling because if wise reasoning is a set of techniques, AI has structural advantages humans don’t. It has no ego to protect. No fear contaminating its analysis. No career on the line. It can run perspective-taking on a difficult decision without the emotional cost we pay. Grossmann’s research highlights what he calls Solomon’s paradox — humans reason more wisely about other people’s problems than their own⁷. AI is structurally always reasoning about someone else’s problem. That’s not a bug. That might be a feature.

But — and this is where the operator thesis still holds — AI doesn’t have skin in the game. It doesn’t bear the consequence of its reasoning. It doesn’t know what it feels like to make the wrong call about something that matters. The wisdom that comes from having lost something important, made a hard decision, watched it unfold over years — that’s not in the training data. And the moral grounding that wisdom requires isn’t there either. AI can simulate caring about shared humanity. It can’t actually care.

Which makes me think the operator’s edge isn’t being wiser than the machine. It’s being wiser with the machine. Use AI to run the reasoning moves where ego gets in the way — perspective-taking, scenario generation, steel-manning arguments you don’t like. Let it execute the technique. Then bring your own moral grounding, your own stakes, your own willingness to live with the consequences. That’s the partnership.

The other-person trick. Grossmann's research highlights that we reason more wisely about other people's problems than our own. Next time you're stuck on a decision, describe your situation as if it's someone else's. Then ask AI to advise that person. You'll get better reasoning — from the AI and from yourself — because the ego is gone. Researchers call this illeism: thinking about yourself in the third person. Marcus Aurelius did it. Caesar did it. It works.

The Grossmann/Bengio/Mitchell paper ends on a note worth taking seriously. If we build wise AI well — not just capable AI — it could function as a cognitive prosthetic at scale. The interesting question isn’t whether one person becomes wiser using AI.

It’s whether nations, institutions, and humanity collectively can reason better. Most of our hardest problems — climate, pandemics, war, technological transitions — fail not at the individual level but at the coordination level. Multiple legitimate perspectives that can’t be reconciled. Long time horizons we struggle to weigh against short-term incentives. Radical uncertainty no single actor can resolve. These are exactly the intractable problems wisdom evolved to handle. Wise AI embedded in institutions might give us tools to handle them at a scale humans never could alone.

That’s the version of the future I’d bet on. Not because I’m certain. Because it’s the bet worth making. The doomsday narrative around AI focuses on misaligned superintelligence destroying us. The more interesting possibility is the opposite: AI helping humanity finally grow up.

So can machines be wise? Not yet. The reasoning strategies that define wise reasoning in humans are also the roadmap for building them into AI — and we’re making real progress on the metacognitive layer. But moral grounding remains the harder problem. Wise reasoning without moral grounding is technique without direction. We can give AI the technique. The direction has to come from us.

That should make us both humble and curious. Humble because wisdom turns out to be less mystical than we’d like — and AI might execute parts of it more reliably than we do. Curious because if we can build wise reasoning into machines, we can build it into ourselves — and maybe into the institutions that will need wisdom most.

PS. Big shout out to Sławomir Jarmuż, the mentor of our wisdom group and the author whose work first sent me down this rabbit hole. And to Adrianna, who introduced me to the group in the first place. And to the whole wisdom-seeking group — many discussions, many disagreements, much fun.

References

1. Grossmann, I. (2017). Wisdom in context. Perspectives on Psychological Science, 12(2), 233–257. — wise reasoning as context-dependent practice rather than stable trait.

2. Grossmann, I., Weststrate, N. M., Ardelt, M., et al. (2020). The science of wisdom in a polarized world: Knowns and unknowns. Psychological Inquiry, 31, 103–133. — the Common Wisdom Model and the two-pillar definition.

3. Johnson, S. G. B., Karimi, A.-H., Bengio, Y., Chater, N., Gerstenberg, T., Larson, K., Levine, S., Mitchell, M., Rahwan, I., Schölkopf, B., & Grossmann, I. (2025). Imagining and building wise machines: The centrality of AI metacognition. — the framework this essay is built on.

4. Ji-An, L., Xiong, H. D., Wilson, R. C., Mattar, M. G., & Benna, M. K. (2025). Language models are capable of metacognitive monitoring and control of their internal activations. — empirical evidence that LLM metacognition is real but partial.

5. Steyvers, M., & Peters, M. A. (2025). Metacognition and uncertainty communication in humans and large language models. — survey of where models still fall short on uncertainty awareness.

6. Bilal, A., Mohsin, M. A., Umer, M., Bangash, M. A. K., & Jamshed, M. A. (2025). Meta-thinking in LLMs via multi-agent reinforcement learning: A survey. — overview of current meta-reasoning approaches and their frame-bound nature.

7. Grossmann, I., & Kross, E. (2014). Exploring Solomon’s paradox: Self-distancing eliminates the self-other asymmetry in wise reasoning about close relationships in younger and older adults. Psychological Science, 25(8), 1571–1580. — the empirical study of Solomon’s paradox.

In 1911, two teams raced to be first to the South Pole. Norwegian Roald Amundsen marched exactly 20 miles every day — no more in good weather, no less in bad. British Robert Falcon Scott pushed hard on good days and collapsed on bad ones. Amundsen won. Scott died on the return. The lesson: be consistent. Set a pace you can sustain. Don’t sprint.

It’s a powerful story. I believed it for years.

Then I went to Dundee — we have an Opera office there — where Scott's ship, the RRS Discovery, is permanently docked as a museum. I stood on the deck. Cleaned it, actually (long story). Stood at Scott's desk and tried to imagine what curiosity and drive a person needs to feel to set off on a 1,000km trip into the Antarctic.

And when I dug into the real history, the parable fell apart.

Scott didn’t lose because he lacked discipline. He lost because of specific, falsifiable decisions. He chose ponies over dogs — despite Fridtjof Nansen personally telling him “dogs, dogs and more dogs.” Ponies sweat through their skin; in Antarctic conditions, the sweat freezes and the animal dies. Dogs cool through panting. Scott’s daily rations provided under 4,500 calories. Man-hauling burned 7,000. On the plateau, 11,000. Amundsen’s team reported gaining weight during their expedition. And Amundsen didn’t march a steady 20 miles — his diary records full rest days, multi-day storm stops, and deliberate pace changes.

The “consistent daily discipline” lesson is a retrofit. A story that survives because it’s compelling, not because it’s accurate. Change “Antarctic expedition” to “startup” and the lesson survives unchanged. That’s a sign the explanation isn’t doing real work.

So the myth is wrong. But I bet even after reading this, you still believe in it. I do :) Belief perseverance in action. The 20-mile march still works as a mental model. Not because of the history. But because we intuitively feel it’s true.

And science is actually on our side. Just not Collins’ version of it.

The spacing effect is one of the most replicated findings in psychology. Distributed practice — spreading learning over time — outperforms massed practice by 10–30%. This isn’t opinion. It’s measured across hundreds of studies. Your brain consolidates learning primarily during the gaps between sessions, not during the sessions themselves. Nine hours straight is worse than one hour across nine days. Not slightly worse. Measurably, significantly worse.

Ericsson’s research on deliberate practice found something most people misquote. The famous “10,000 hours” gets all the attention. The part that matters more: elite performers top out at roughly 3-5 hours of focused practice per day. After that, quality drops off and diminishing returns kick in. Not because they lack motivation, but because their cognitive systems can’t sustain the required attention. The violinists who practiced 4 hours and napped outperformed the ones who practiced 8 hours and pushed through.

Spacing means the gaps matter more than the sessions. Ericsson means there’s a daily ceiling. The sprint pattern violates both. The march pattern respects both. One thing, one hour, every day. Gaps between sessions. Well under the ceiling.

I think about this standing at Scott’s desk. He wasn’t lazy. He wasn’t undisciplined. He was a genuinely brave, capable leader who made specific wrong decisions under uncertainty. The lesson isn’t “be more consistent.” The lesson is: preparation beats heroism. Specific decisions beat generic discipline.

Applied to AI: the landscape in six months won’t be the same as today. Half the tools you’re sprinting to master will be replaced by something better. The person who spends one focused hour every day will have compounded more than the person who burned out in week three. Not because consistency is morally superior. Because the brain has specific constraints on learning and attention — and effective strategies work within those constraints rather than pretending they don’t exist.

Don't let AI FOMO fry your brain. One focused hour a day is enough — not nine-hour sprints, not weekends lost to exhaustion. Pick one specific question you're trying to answer. Write down what you learned. In six months you'll have compounded more than the person who sprinted and crashed. The AI landscape will have changed twice by then anyway.

And leave time for the things that actually matter. The close ones. Good food. Life. No model update is worth missing that.

The march doesn't have to be 20 miles. It just has to be daily. And you still have to be walking in six months…

PS. Enough is enough. “—” is beautiful. Option+Shift+’-’. I’m on Opera Neon, and adding em dashes with wild satisfaction where I want them, despite the rants of ChatGPT “lovers”.

Appendix: what actually happened in Antarctica

For the curious. Skip, or stay — choice is yours.

Scott’s cascade of specific failures

The ponies. Scott brought 19 Manchurian ponies, 34 dogs, and 3 motor sledges. The ponies were purchased by Cecil Meares — a dog expert, not a horse expert — because Captain Oates couldn’t join until May 1910. Upon seeing them, Oates reportedly called them “the greatest lot of crocks he had ever seen.” Of 19 ponies, 9 were lost before the polar journey began, several drowned on disintegrating sea ice. Ponies required warmer weather to travel, forcing Scott to delay departure until November 1st. Amundsen left October 19th, an 11-day head start. And as mentioned already — ponies do sweat.

The motor sledges. Scott invested heavily in motor sledges — spending roughly seven times more on them than on dogs and ponies combined. In practice, the technology proved unreliable... The first fell through thin sea ice during unloading and sank. The remaining two failed after covering just 50 miles in 7 days. Worse: Scott had left behind Lt. Cmdr. Skelton, the engineer who designed the sledges — all due to a rank protocol dispute. He lost irreplaceable expertise over a personnel squabble (yes, facepalm).

The caloric miscalculation. Scott’s daily rations provided (by most estimates) under 4,500 kcal/day. Man-hauling burned approximately 7,000. During plateau ascent, 11,000. A daily deficit of over 2,500 calories. In contrast: Amundsen reported his team gained weight...

The fuel tins. Scott’s kerosene was stored in tins sealed with cork stoppers and leather washers. Fuel crept past imperfect seals and evaporated. This was already a known phenomenon from previous expeditions. When returning parties opened cached tins, they found them partly empty: no fuel meant no melting snow for water. Amundsen soldered his tins shut. A depot he left was found 50 years later, still full.

The clothing. Scott’s team wore woolen underwear with windproof outer layers; sweat froze inside during heavy man-hauling. Amundsen’s team wore loose-fitting Inuit-style furs allowing air circulation.

One Ton Depot. Planned for 80°S but placed at 79°29’S — 35 miles short — because the ponies were struggling. Oates urged killing the weakest for dog food and pushing on. Scott refused: he’d had “more than enough of this cruelty to animals.” Scott’s party died approximately 11 miles south of One Ton Depot.

Amundsen’s specific decisions

Dogs as a system. 5 men, 4 sledges, 52 dogs. Paced deliberately — daily mileages kept shorter than necessary for 75% of the journey, with up to 16 hours/day resting. At the top of the Axel Heiberg Glacier, 24 dogs were deliberately killed. Their carcasses were eaten by remaining dogs and men. This provided fresh meat and helped supplement the team’s nutrition, contributing to better overall energy and health. Fresh meat also contains small amounts of vitamin C, which likely helped reduce deficiency risk.

The depot-marking system. Each depot had bamboo flags every half-mile for 5 miles on each side — a 10-mile-wide safety net. Each bamboo was numbered so the returning party could determine which side the depot lay on and how far away. Scott’s depots had a single flag.

Superior nutrition. Amundsen’s pemmican contained oatmeal and peas — providing fiber, B vitamins, and some vitamin C. His biscuits used wholemeal flour, oats, and yeast. Scott’s used plain white flour. Amundsen’s daily rations: approximately 5,000 calories plus food from killed dogs.

Lighter equipment. Olav Bjaaland planed down the sledges by roughly one-third. Amundsen used a sextant (light, simple); Scott used a theodolite (heavier, more complex). Four of Amundsen’s five men were qualified navigators. Scott had one per team.

Skiing. Amundsen's team grew up on skis. They also had Olav Bjaaland, a champion skier. Scott hired Norwegian Tryggve Gran to train his men, but never made it compulsory. His own diary entry says it all: "Skis are the thing, and here are my tiresome fellow countrymen too prejudiced to have prepared themselves for the event."

The weather

March 1912 was unusually cold. Susan Solomon and Charles Stearns (PNAS, 1999) provided the definitive meteorological analysis: during Scott’s return, temperatures were far colder than normal — on some days, minimums were more than 11°C colder than the climatological average. Only 1 year in 15 showed similarly persistent cold. Bad luck was real. But Amundsen’s margins were so wide that similar conditions would likely not have been fatal for his team.

Amundsen's own words crystallize this: "Victory awaits him who has everything in order — luck, people call it. Defeat is certain for him who has neglected to take the necessary precautions in time; this is called bad luck."

If the Antarctic history hooked you, check this one: Roland Huntford, The Last Place on Earth — the definitive dual biography of Scott and Amundsen.

I know this because I live it. The moment AI reduces friction between point A and point B, it feels like a teleport. You know exactly where you need to go, and suddenly you’re there. That’s the high. It’s genuinely exciting. And that excitement is the trap, because it’s 11pm and you think “just one more thing” and then it’s 2am and tomorrow is destroyed. I had to catch myself and actively correct this pattern to not end up there every night.

A new study by Boston Consulting Group, published in Harvard Business Review, confirms this isn't just me. They surveyed 1,488 workers and found something important: AI doesn’t cause traditional burnout. When AI replaces repetitive tasks, burnout actually drops 15%. But it causes something else: they call it “brain fry.” Mental fatigue from overseeing AI beyond your cognitive capacity. 14% of AI users report it. Those who do make 39% more errors, and are 39% more likely to want to quit.

This distinction matters. Burnout is emotional exhaustion from bad work. Brain fry is cognitive overload from work that feels great but moves faster than your brain can process.

Here’s what I notice in my own workflow. There are two phases where AI feels completely different:

Phase 1: Definition. You’re defining what to build, what strategy to execute. AI helps you think, structure, explore. This is the teleport phase. It’s energizing because you’re planning, creatively building, making decisions. And AI is compressing the distance between the decision and the result.

Phase 2: Iteration. You’ve built something, now you’re improving it. Test, verify, adjust, get feedback from users, from the team. Iterate. This is where the trap opens - because between iterations, while AI is executing, you’re waiting. And you feel like you could do something more. So you start a second project. You switch to reviewing documents. You ask AI agents to run changes across different projects. You start sketching yet another product. And suddenly you’re context-switching between four or five different things and your brain melts.

The study suggests the number of tools is a key driver of fatigue. In my experience, that’s not the main factor. I regularly use 10+ tools on a single project and it doesn't fry me at all. What actually breaks me is switching between projects - each one requiring a different mental model.

AI doesn’t overload you because it’s complex.
It overloads you because it removes natural stopping points.

AI is executing, and you’re waiting. That gap feels like wasted time. So you start something else.

A second project. A document review. Another idea.

Now you’re not iterating - you’re context switching. And every unfinished thing stays active in your head.

That’s attention residue. That’s the Zeigarnik effect.
It’s not the work that overwhelms you. It’s the number of open loops.
(Sophie Leroy and Bluma Zeigarnik studied this long before AI made it everyone's daily experience.)

Every context switch is expensive - for you and for the AI. Think of it like an LLM on a GPU. You load the model, allocate memory, fill the context window. The agent knows your project, your documents, your workflow, your intent. Then you switch it to a different project and you dump all that state. Fresh session. Cold start. Now multiply that cost across your own brain. You’re doing the human equivalent of cold-starting a new inference session every time you switch tasks - except your brain also keeps ghost processes running from every previous session. Unlike a GPU, you can’t kill those threads.

What I've learned the hard way. Work in batches. One project at a time. When AI is executing and you feel the itch to start something else - write down the thought, capture it, but don't switch. The context in your head is as expensive as the context in the model. Protect both.

When you've lost track of what you were even trying to do - stop. Use AI to get yourself out. Ask it to summarize everything that's happening. Get the helicopter view. Rebuild your mental model from the top down instead of from the fragments.

Pick your battles for a given day, maybe even for a few days. Go deep on one thing only. The 20-mile march applies here: sustained focus on one thing beats sprinting across four.

And please - in between, don't add more articles, PDFs, and pages to your LLM wiki. Why would you do that to yourself. Your second brain will not replace your first. Go for a walk instead.

The irony is sharp. AI's biggest promise is removing execution bottlenecks. But the new bottleneck is attention - and unlike execution, attention doesn't scale.

Their argument: hierarchy has always been an information routing system. Romans, Prussians, railroads, modern corporations - all of them solved the same problem of coordinating people through layers of human managers passing information up and down. AI can now do that routing instead. So you don’t need the layers anymore. Replace middle management with a “world model,” flatten the org, put everyone on the edge.

I’ve been chewing on this for years, not just as theory. I tried building a Sociocratic organization at Opera. Sociocracy replaces consensus with consent - you don’t need everyone to agree, you need nobody to have a principled objection. It’s elegant. It’s intellectually honest. And in practice, it works until it doesn’t. At a certain scale, someone still has to make the call that nobody wants to make. The mechanism for reaching agreement isn’t the bottleneck. The willingness to own the consequence is.

That’s where the essay gets interesting but also where it gets harder to pin down. The strongest idea in the piece is that Block’s transaction data is an honest signal. People lie on surveys, ignore ads, abandon carts - but when they spend, that’s truth. I genuinely think that’s right. That’s a real compounding advantage, and I can’t poke a hole in it.

But the leap from “we have great data” to “we can replace hierarchy” is where I start having questions. The essay proposes a “world model” that replaces what managers do. But what decides what the model optimizes for? Who intervenes when the model is wrong in a way that costs real trust? Who says no to a project that the data supports but judgment says is wrong?

I actually think you could encode principles for AI to manage by - something like a smart contract for organizational decision-making. A written-down set of rules, priorities, constraints. And if you think about my earlier posts on operators, there’s a version of this where the manager’s role shifts from information routing to making sure the vision actually gets carried out across hundreds of people. That’s not a lesser role - it’s a different one. And if AI can handle the routing part, managers can focus on the part that actually requires human judgment: developing people, navigating ambiguity, and making the calls the system can’t.

The essay proposes three roles: ICs, DRIs, and player-coaches. No permanent middle management. The DRI has full authority to pull resources across teams for 90 days. That’s compelling on paper. But someone decides who becomes the DRI. Someone decides which problems matter enough. Someone evaluates whether they succeeded. I’m not sure that’s as different from hierarchy as it sounds.

Many have promised this revolution before. The internet was supposed to flatten organizations. Slack was going to eliminate information silos. Holacracy tried to remove management titles entirely. Spotify had squads. I tried Sociocracy. Every attempt taught me something, and every one eventually hit the same wall: coordination at scale needs someone willing to bear consequences, not just route information.

And that’s the question the essay doesn’t fully answer. AI can route information better than any human manager. I believe that. AI can probably maintain a world model of company operations that’s more accurate and more current than any executive’s mental model. I believe that too.

But can AI bear consequences? Can it be the one who says “this was my call and it was wrong”? Can it face the team after a failed bet and explain what it learned? Can it fire someone? Can it choose to take a risk that the data doesn’t support because something in the situation demands it?

Not yet. Maybe not ever. I genuinely don’t know.

What I do know is that the cost of being wrong about this is asymmetric. If you flatten too slowly, you lose some speed. If you flatten too fast and remove the humans who own the consequences, you get a system that optimizes beautifully until the moment it fails catastrophically and nobody owns the failure. Taleb would call that a fragile system disguised as an efficient one.

I think Dorsey is right that organizations are too slow. I think he’s right that AI can take over a huge chunk of what middle management does. But I think there’s a distinction worth drawing: AI as a better coordination mechanism (probably true, already happening) and AI as a replacement for human accountability (extraordinary claim, no evidence yet). The first is an operational improvement. The second is an organizational revolution. They’re not the same thing.

It’s a great debate to have. I suspect the answer will be somewhere in between - not the hierarchy we have, and not the flat intelligence the essay describes, but something messier. Something where AI handles coordination and humans handle the consequences. Which, if you think about it, is just the operator model applied to organizations.

I read it and thought: what if we went further? Caveman tells the model to shut up. What if instead we told it what kind of thinking to keep?

I forked the repo and spent an afternoon building philosopher modes.

The philosophers

Three modes, each encoding a different epistemological filter as a system prompt. The names come from the thinkers, the modes are the concepts:

Hard-to-vary mode (from David Deutsch). Every detail in the response must be load-bearing. If you can swap a noun and the sentence still works, the noun was decorative. Kill it. Name the mechanism, not the category. “It’s a race condition” gets deleted if you also wrote “X and Y both write to Z.” The mechanism IS the explanation.

Falsifiable mode (from Karl Popper). Every claim must come with its refutation test. No “might work,” no “best practices,” no “it depends.” Every diagnosis includes how to disprove it: “Conjecture: stale cache. Falsify: curl -H ‘Cache-Control: no-cache’. Same error? Not cache.” If you can’t state what would prove you wrong, don’t state it.

Antifragile mode (from Nassim Taleb). Via negativa applied to technical advice. Subtract before you add. Name the fragility before the feature. “Fragile: monolith deploys = all-or-nothing. Remove: coupling via shared DB.” Lead with what to stop doing. State the asymmetry. No “on the one hand, on the other hand.”

I ran all three against caveman and a normal baseline across 10 technical prompts, 5 models, 3 trials where budget allowed. Over 1000 tests total. Used the existing caveman benchmark (same prompts, same measurement: output token count, no quality scoring).

The first results looked like a breakthrough

On Sonnet 4.6, the philosophers dominated:

Antifragile: 62% average token savings. Falsifiable: 58%. Hard-to-vary: 53%. Caveman: 52%.

Antifragile hit 82% on some prompts. The “subtract first” framing maps cleanly to terse answers. Falsifiable’s conjecture/falsifier pattern compressed even on review tasks where the model would normally hedge for paragraphs. I wrote in my notes that caveman was “Pareto-dominated.”

I was wrong.

The philosophers got beaten. Hard.

Then I tested other models. And the picture inverted.

Opus 4.6: every mode lost ground. Hard-to-vary went negative on one prompt, producing 15% more tokens than baseline. The “name the mechanism, go one level deeper” rules added explanatory structure that cost more tokens than it saved. On a topic where the answer IS an explanation, the rigor budget ate the compression budget.

Haiku 4.5: the structural modes collapsed. Hard-to-vary averaged 10% savings. Five out of ten prompts went negative. The worst was -46%. Meanwhile caveman sat at 52%, identical to its Sonnet score.

gpt-5.4-mini: complete ranking inversion. Caveman won. Falsifiable collapsed to 18%.

gpt-5.4 (reasoning auto): three out of four modes produced more tokens than baseline on average. Antifragile went -87% on one prompt. Even caveman struggled.

Caveman: 31 points of variance across models. Hard-to-vary: 70. Falsifiable: 77.

But I saw something in the wreckage.

What the failures revealed

The philosopher modes have rules that add required content. “Name the mechanism.” “State the falsifier.” “Name the fragility.” These are positive injection rules. On Sonnet, the model is smart enough to compress while satisfying those rules. On smaller or differently-tuned models, it satisfies them by expanding.

Caveman has only deletion rules. Its worst case is no-op. It can never make things longer because every rule says “remove,” never “add.”

Subtraction is robust. Addition is fragile.

The making of the ultraphilosopher

The question became: can you keep the philosophical content but express every rule as a deletion?

Here’s the core reframing. Same filter, different expression:

Hard-to-vary (positive injection): “Name the mechanism, not the category”

Ultraphilosopher (deletion): “Delete category-level claims when a mechanism statement exists”

Falsifiable (positive injection): “Every recommendation includes failure condition”

Ultraphilosopher (deletion): “Delete claims you cannot state a falsifier for”

Antifragile (positive injection): “Expose hidden optionality”

Ultraphilosopher (deletion): “Delete recommendations that don’t acknowledge a tradeoff”

One set of rules can expand output. The other can only shrink it. The worst case for ultraphilosopher is “did nothing.” It literally cannot make things worse (last famous words).

I also built two companion modes on the same principle:

Imperatives restricts grammatical mood. Every non-code sentence must be a command. “The bug is caused by X” becomes “Fix X.” If a sentence can’t be rewritten as an imperative, delete it.

Anti-elaboration is a pattern blacklist. Delete intros (”I’ll help...”), delete transitions (”Furthermore...”), delete closings (”Hope this helps!”), delete restatements.

I committed to a falsifier before testing any of them: average savings on Haiku must exceed 30%, no prompt may go negative by more than 10%. If the mode fails this test, it doesn’t ship.

What the ultraphilosopher actually produces

The prompt: “Why is my React component re-rendering?”

Normal response (~822 tokens on Sonnet): multiple paragraphs explaining shallow comparison, object references, the React reconciliation algorithm, several possible causes, caveats, and a gentle suggestion to try useMemo.

Ultraphilosopher (~116 tokens, 86% saved):

Inline obj prop → new ref each render → shallow compare fails → re-render.

Wrap in `useMemo`. Falsify: useMemo deps wrong → still re-renders.

The mechanism is there (object literal creates new reference). The falsifier is there (wrong deps breaks the fix). The category-level filler (”this is a common React performance issue”) is gone because ultraphilosopher’s rule says: delete category-level claims when a mechanism is stated. The mechanism already told you it’s a performance issue. Saying so adds zero information.

“Should I use Redis?”:

Redis fits read-heavy + tolerates stale + dataset < memory.

Wrong if write-heavy + needs consistency: invalidation cost > DB cost.

Test: hit ratio week 1 — under 80% means wrong tool.

Three conditions, one failure case, one empirical test. No “there are several factors to consider.”

The results

All three new modes passed. None went negative on any prompt across any model tested.

On Sonnet 4.6, ultraphilosopher hit 73% average savings. The previous champion (antifragile) had been 62%. On one prompt, ultraphilosopher saved 90% of tokens. Its worst result on Sonnet (51%) was still higher than caveman’s average.

On Haiku, where hard-to-vary had collapsed to 10% and gone negative on five prompts, ultraphilosopher delivered 58%. Same philosophical content, different rule expression. The deletion-only reframing moved Haiku compression from 10% to 58%.

On gpt-5.4-mini: ultraphilosopher 71%, imperatives 67%. Both beat round-1 caveman (48%) by over 20 points.

The megasaiyan experiment

I tried fusing all three winners into one mode. The conjecture: content subtraction, syntactic restriction, and ceremony deletion attack orthogonal axes. Combined, they should compound.

I committed the falsifier before testing: megasaiyan must beat the best single component by at least 5 points. If it doesn’t, the fusion hypothesis is falsified. Ship the components separately.

It didn’t. Megasaiyan averaged 67% on gpt-5.4-mini. Ultraphilosopher alone: 71%. On one prompt, imperatives scored 81% with pure command form while megasaiyan dropped to 43%. The philosophical filters reintroduced descriptive content that imperatives correctly deletes. The rules interfere.

Without a pre-committed criterion, I would have looked at 67% and called it competitive. With the criterion, the decision was automatic. Fusion falsified. Ship the components separately.

What this is and what it isn’t

What it isn’t. Serious research. Ten prompts, one domain (technical/coding), no objective quality measurement. A 60% token saving that produces a wrong answer is a regression, not a win. I used the existing caveman benchmark, not my own. No long sequences, no long context windows, no multi-turn conversations, no non-English prompts. I tested five models from two vendors. The sample would make a statistician cry.

What it is. An afternoon experiment that produced a testable design principle and one working mode that outperformed everything else on every model I tested.

What I notice using it. Responses feel visibly faster. When 70% of tokens disappear, the response arrives in a fraction of the time. For technical work, where I already know the domain and want the model to be precise rather than educational, the compressed answers feel better to me. That’s an anecdote, not data.

I’d be curious to learn the answers

Do shorter skill files survive better on smaller models? The input token cost per call might matter more than I assumed.

Does compressed output lose accuracy, or (as the original brevity paper suggests) does it sometimes improve it? A quality benchmark would answer whether the philosophers are actually smarter than the cavemen, or just quieter.

Does this generalize beyond coding prompts? Writing, analysis, research, creative work have different compression profiles. The principle (subtraction beats addition) should hold. The magnitude is an open question.

What survived falsification

After 1000+ tests across 5 models and 9 modes, three conjectures falsified:

“Bigger model = better compression.” Wrong. Opus and gpt-5.4 compressed worse than their smaller siblings. Not because they ignored the instructions, but because their reasoning overhead is structural. They may follow compression rules perfectly and still produce more tokens.

“Structural rules with positive injection scale across models.” Wrong. They work on Sonnet and collapse everywhere else.

“Fusion of orthogonal compression strategies compounds.” Wrong. The rules interfere.

Two confirmed:

Subtraction-only rules generalize across model sizes. And the relationship between model size and compression effectiveness is non-monotonic, with a sweet spot in the middle.

The design principle I’d carry forward to any system prompt work: if you can express a rule as a deletion, do it. The worst case is no-op. The moment you ask a model to add something, you’ve opened the door to unbounded expansion.

Why this matters

Output tokens are the expensive part of any API call. At the time of writing, Sonnet 4.6 charges $15 per million output tokens. Haiku 4.5 charges $5. Opus 4.6 charges $25.

Ultraphilosopher saves 73% of output tokens on Sonnet. That’s $10.95 per million tokens you don’t generate. On Haiku, 58% savings = $2.90 per million. On Opus, if the numbers hold, you’re looking at roughly $12-13 saved per million output tokens.

Scale that to a production workload generating 100M output tokens per month on Sonnet. Normal cost: $1,500. With ultraphilosopher: ~$405. That’s $1,095/month from a system prompt change. No infrastructure work, no model switch, no fine-tuning.

And the cost saving is arguably the less interesting part. The latency improvement is proportional to the token reduction. 73% fewer tokens means the response arrives in roughly a quarter of the time. For agentic workflows where one LLM call feeds into the next, that compounds across every step in the chain.

The results are here, benchmarks, raw JSONs, all skill files, including the ultraphilosopher. Shout out to Julius Brussee and the original caveman authors for building something worth forking.

More experiments coming.

Here are four things. If you do all four, you’re an operator. If you don’t, AI will be a very fast way to produce things nobody needs.

Define what should exist

Not “write code.” Not “build a deck.” Not “design a screen.” Those are execution tasks. The operator question comes before all of that: what’s the actual problem, and is it worth solving?

This is problem selection, framing, and prioritization. It’s the hardest part because it’s where most projects go wrong, and no amount of execution speed fixes a bad starting point. AI can generate a hundred solutions in an afternoon. But a hundred solutions to the wrong problem is worse than no solutions at all, because now you’ve spent time evaluating garbage.

I’ve seen this pattern for 20+ years, including in my own teams. The ones that struggle aren’t the ones that can’t build fast enough. They’re the ones that can’t decide what to build.

Judge quality

AI can generate infinite outputs. Operators decide what’s good, what’s mediocre, and what’s wrong.

This is taste. And taste is weirdly hard to talk about because it sounds subjective, even elitist. But it’s not. It’s pattern recognition built from years of seeing what works and what doesn’t. The designer who looks at a layout and immediately knows the hierarchy is off. The engineer who reads an architecture proposal and sees the scaling problem that will hit in six months. The strategist who reads positioning copy and knows it could be about any company.

I haven’t seen anyone Google their way to taste or prompt their way to it yet. Maybe it’s possible. I’d love to see the evidence. But so far, taste seems to develop the old-fashioned way: by caring, repeatedly, over a long time, about whether the output is actually good.

Iterate directionally

Not just “try again.” It’s tempting to just ask again with slightly different words and hope for something better. I catch myself doing it too. But that’s a slot machine approach — you’re pulling the lever hoping for a different result without changing anything that matters.

There’s a line often attributed to Einstein: you can’t solve a problem with the same thinking that created it. Whether he said it or not, applied to AI it’s exactly right. Rephrasing the same question is useless. The question was wrong, not the answer. Change the question.

Operators iterate directionally. This is wrong because of X, so change the approach to Y. The texture is right but the composition fails, so keep the texture and restructure. The argument is solid but the order kills the pacing, so resequence without losing the logic.

This is feedback loops and course correction. It requires knowing not just that something is wrong, but why it’s wrong and what would make it right. AI is extremely good at executing corrections. But it needs a human who can diagnose the actual problem, not just the symptom.

Own outcomes

Not “I completed the task.” Operators say “this worked or it didn’t, and it’s on me.”

This is the rarest one. Most people in organizations are optimized for task completion. Ship the feature. Deliver the deck. Hit the deadline. Whether the feature actually moved the metric, whether the deck convinced anyone, whether the deadline mattered — that’s someone else’s problem.

Operators close the loop. They care about what happened after the work shipped. Did it work? If not, why? What do I change next time? This is where judgment actually compounds, because you’re building a feedback loop between your decisions and their consequences.

AI can’t do this for you. It has no skin in the game, as Taleb would say. It doesn’t know if the output worked in the real world. It faces no consequences for being wrong. Only you know that, and only if you bother to check.

The test

Here’s a simple way to know if you’re operating or just executing. Ask yourself: if the AI disappeared tomorrow, would you still know what to build and whether it was good? If yes, you’re an operator using AI as leverage. If no, you’re a passenger and the AI is driving.

That’s not a judgment on anyone’s worth. Plenty of brilliant people are early in developing these skills. But knowing the difference matters, because the people who think they’re operating when they’re actually just prompting are the most vulnerable ones in the room.

​​Before you prompt, answer three things. What problem am I solving? How will I know if the output is good? What does "wrong" look like? Write it down - one line each. Takes 30 seconds. Sounds obvious. Try it - most people discover they can't answer the second one without thinking for ten minutes. That's the gap between prompting and operating. AI is very good at executing wishes. The results vary.

Bonus: once you have your three answers, paste them twice inside your prompts. Sounds silly, but repeating your intent in the prompt measurably improves output quality across all major models. Your judgment, stated clearly and repeated, is literally the best prompt engineering there is.

Because here’s the uncomfortable part. Before AI, you became an operator by doing execution work for years. You wrote the code, built the decks, ran the analyses, made the mistakes, learned the patterns. Execution was the training ground for judgment. It was slow and often painful, but it worked.

That layer is disappearing.

Which creates a real paradox: companies want operators, but the traditional path to becoming one is being pulled out from under people’s feet. If AI handles the execution, where do juniors learn?

I care about this question for two reasons. First, I remember being junior. I was arrogant, probably stupid in many ways, but I was curious, ambitious, and cared about producing quality work. And that came before I had any real experience. I was doing heavy lifting in assembler and 3D graphics, not because someone told me to, but because I wanted to see if I could squeeze a few more cycles out of a shading routine (and was lucky to have a 56kbps modem and access to hornet ftp). Nobody taught me taste. I developed it by caring obsessively about whether the output was good or bad.

Second, my son is heading to university soon. The world he’s entering is completely different from the one I entered. This isn’t abstract for me.

That instinct to care doesn’t go away because AI exists. But the path changes.

The old path was linear: do tasks, learn patterns, build judgment, become operator. You couldn’t skip steps. The execution work was the curriculum.

The new path is different. You use AI to handle execution, then spend your time reviewing and correcting the output. Did the AI make the right architectural choice? Is this positioning actually sharp or just smooth? Does this code solve the real problem or just the stated one? The skill shifts from doing to evaluating.

This is actually faster, if you approach it right. A junior today can see more outputs, compare more approaches, and test more assumptions in a week than I could in a year of manual work. The iteration cycle compresses. Taste can develop faster when you have more material to judge.

Here’s a real example. I was recently working on a project that needed AI-generated images with a consistent visual style across dozens of outputs. This is a project I work on in the evenings, by the way. Not a browser ;-). Just something I wanted to build.

I started the traditional way, by researching how other people build image prompts, trying to understand how different models respond to different instructions. It was painfully slow.

So I changed the approach. I set up a feedback loop: AI generated prompts, I evaluated the images as they came in, one every few seconds, and just gave quick feedback. This is good. That’s wrong. The texture works but the composition doesn’t. I noticed patterns in what made outputs consistent and fed those observations back. Within an hour, burning through an enormous amount of tokens, I’d compressed what would have been weeks of manual experimentation.

But here's what surprised me. The result wasn't what I expected. I didn't end up understanding how to write great image prompts myself. Instead, I built a system that generates them better than I ever could.

My judgment was the input — what looks right, what doesn't, what "consistent" actually means in context. The AI handled everything else.

That’s the operator pattern in miniature. You don’t become good at execution. You build systems that make your execution irrelevant. Your taste is the only thing that can’t be automated out of the loop.

And of course someone will read this and say: once your taste is extracted into the system, you’re no longer needed. Fair objection.

All I can say is what I observe right now: the system I built only works because I keep feeding it new judgment. New styles, new contexts, new “that’s wrong and here’s why.” The moment I stop, it stops improving, or worse - it drifts away. Whether that stays true is one of the most interesting open questions in AI. I’m betting it will, but I’m honest enough to say that’s a bet, not a proof.

But there’s a trap, and it’s not just for juniors. Anyone who just accepts what the AI gives them learns nothing. You become a prompt-typist, not an operator. The AI did the work, you shipped the result, and you have no idea why it was good or bad. You skipped the judgment part entirely. This is everyone’s problem.

The people who win are the ones who obsess over why. Why is this output good? Why is that one garbage? What would I change and why? They treat AI output the way you treat KV cache optimization - as something to evaluate, challenge, and squeeze until it’s actually right. Not something to accept.

The people who lose are the ones who confuse speed with learning. They ship more but understand less. And when the AI gets something wrong in a way that matters, they can’t catch it.

A small habit worth trying. Every time you review an AI output, stop and think why it's good or why it's bad. Best even - write it down. Not for anyone else, for yourself. Keep it as an MD file. Try this for two weeks and my bet is it will accelerate your taste development faster than months of execution work. You're training your judgment on every output instead of every task. Inspired by a Haystack Method from Rohit Bhargava's Non-Obvious; just applied to AI.

I should be honest: I don’t know how this plays out at scale. We’re running a massive experiment on professional development and nobody knows the results yet.

But I’m actually really optimistic. Boris Cherny, who built Claude Code at Anthropic, has a parable I love. He compared AI coding to the Gutenberg Press. Before Gutenberg, scribes controlled text. The printing press eliminated scribes. But scribes were never the writers. Gutenberg enabled millions more people to read and write, and that became fundamental to schooling, to work, to culture. It made it possible for far more people to become creators - writing books that others actually wanted to read.

The same thing is happening now. The fact that everyone will be able to code doesn’t mean everyone will build great products. But it means we’ll all get new powers. You could become proficient in areas where it used to take years to acquire a skill. The path gets shorter. The barrier drops. Will the curious people lead the way, or will only the paranoid survive? Time will tell. I’m betting on both.

AI is for operators

Everyone’s asking the wrong question about AI. The whole conversation is about replacement. Will it take your job, will it make you obsolete. It’s the wrong frame.

Here’s what’s actually happening: AI is eliminating execution. Not judgment. Not taste. Not the ability to know what’s worth building. Just the mechanical distance between a decision and a result.

I’ve spent 20 years building browsers at Opera. Products used by hundreds of millions of people. The bottleneck was never knowing what to build. It was always how long it took to get from “I have an idea worth testing” to “it’s shipped.” Months of coordination, implementation, iteration, debugging, revision. All execution.

AI is compressing that to near zero.

I feel this personally. When I was finishing university, I almost got depressed, not because I lacked ideas, but because I could see that the things I wanted to build would require either decades of solo effort or teams of hundreds. So I took the managerial path. I built organizations instead of code. And it worked — I don’t regret it! — but something was lost.

These days, for the first time in twenty years, I can feel the joy of creation again. The same feeling I had as a teenager, programming on paper (you know, at school, when just a lesson doesn’t fill up your whole ADHD attention span :p), optimizing assembler by hand, trying to squeeze a shading routine into fewer CPU cycles. AI gave that back to me. I have never felt better about what’s possible.

And when execution disappears, something interesting happens. The only thing that matters is whether you had the right judgment in the first place.

This is not about experience level. I’ve seen brilliant work from people in their first year. Ambition and taste aren’t a function of years on the job. But the gap between what you can see and what you can ship, that grows with experience. The more you know, the more you see what should exist. And the more painful the execution bottleneck becomes.

The people who benefit most from AI are operators. People with hard-won judgment who were always bottlenecked by execution. The senior engineer who sees the right abstraction immediately but used to spend two days implementing it. The strategist who knows the positioning but used to spend a week building the deck. AI doesn’t give these people new ideas. It removes the friction between their ideas and reality. And of course, the world has always benefited from those who don’t know something’s impossible and do it anyway. AI supercharges that too.

Andrej Karpathy wrote this week about building personal knowledge bases with LLMs. What struck me most: the human barely touches the wiki directly. The LLM handles compilation, maintenance, cleanup. All execution. The human’s job is deciding what to look at and what questions to ask.

But this only works if the knowledge base is clean. We spent decades learning that code rots without refactoring. Same applies to your data now. Inconsistent, fragmented knowledge in, garbage reasoning out. Data hygiene is the new code hygiene. The operator’s discipline, knowing what’s noise, what’s signal, what structure the information needs, that’s the factor that impacts AI output more than anything else.

Google released Gemma 4 this week. I downloaded it to my NVIDIA Spark the same afternoon. It’s sitting right on my desk together with Nemotron 3 Nano. They’re fast, genuinely smart, and within 20 minutes I’ll have my Mac Mini running an agent farm using these models through the night, researching agent lifecycles while I sleep. More on that soon. But the point is, time from idea to getting things done shrunk to almost nothing.

This is the lens I apply to everything I build. Not “how do we add AI to this?” but “what happens when execution disappears and the user’s judgment is the only input that matters?”

That’s what I mean by AI for operators. AI that makes you the bottleneck — in the best possible way. Because if your judgment is good, everything downstream is right. If it’s bad, no amount of execution speed saves you.

I should be honest about the limits of my own argument. Saying AI only eliminates execution might be too comfortable. Given the right principles and frameworks, AI can reason, plan, validate, and self-correct. So how much of what we call “judgment” is actually pattern-matching from experience, culture, and education — just execution at a higher level of abstraction? And how much is something else, genuine creativity, whatever that means? I don’t know. I’m not sure anyone does yet.

What I do know is that the people who assume AI can’t touch their thinking will be the last to notice when it starts to. And the people who stay curious about where the line actually is, those are the ones I want to build for.

I’ll be writing here about this thesis as I pressure-test it against the products I’m building, against the industry, against my own assumptions. Some of it will be wrong. As Popper would say, knowledge only grows through conjecture and refutation. I’d rather be wrong in public than right in private.