stop asking AI what 2+2 is

The AI honeymoon loop

Everyone is in a looping honeymoon phase with AI: "I can say something in English and it will do magical things," which naturally leads to "let's go make everything happen magically."

Vibe coding is a perfect example of that loop. People who don't care about the problems flock to it, those who do care have to adapt or get left behind, then the seams rip and the discourse moves on to agentic engineering or whatever buzzword gets picked up next from the Karpathys of social media. Which is itself another loop: people are largely prey to the argument from authority fallacy, social media accelerates that weakness, and you end up hearing people speak in words someone else made up, unsure whether they understand the implications of what they're saying.

Behavior tends to stay consistent with incentives, so I don't expect this to change at scale. But some people still care, so here's a different way of looking at it.

Stop asking AI what 2+2 is

I don't want AI telling me that 2+2 is 4. It's a waste of compute and a waste of tokens. The answer is axiomatic, invariant, the kind of thing you get from arithmetic or a lookup or one line of code, and it will never be different. Yet that's what most of us are doing with AI all day: asking it 2+2 in a thousand disguises, paying inference for answers that never needed inference, and accepting the risk that a probabilistic model gets creative with something that has exactly one correct answer.

So let's build systems that don't need to ask those questions. Systems that understand which questions are worth asking, and that can ensure the answers stay correct within whatever model is being applied to the system at any given time.

Telling those questions apart starts with seeing structure. Everything has one. A sentence has grammar, a document has a schema, a product has a topology, and even a preference, which you'd think is subjective, has entities on both ends: a user is a system, a tool is a system, and preference is a mapping between them.

By structure I don't mean folder hierarchies or property names or whatever shape you gave things last quarter. Those are answers. The structure is the questions that give something identity. I was storing all my records in a filesystem behind a pull request and treating that like architecture until I realized it was a storage choice. What the records are, how they relate, where they can live: those questions are the structure, and you can answer them in any way.

AI helped me see that, because it doesn't share my priors, which makes it useful for questioning the things I stopped questioning. That includes me. My vocabulary is an answer, my framing is an answer, the paradigm I learned to think in is an answer, and when something shows me a better path and I feel resistance, that's me defending an answer as if it were the structure. The practice is getting comfortable being debunked, and building so the system expects today's answer to be replaced tomorrow, the way science expects the next experiment to challenge the hypothesis.

Naming was never the problem

Here's what that looked like in real life. Someone had opinions about what properties should be called and how folders should be organized, and the pull to engage was real, but my question was whether the system produced correct answers for specific workflows, and naming isn't even in the same category. Everyone treats folder structure as upstream of correctness because it's always been treated that way, but decompose the problem and it turns out they were never coupled. I couldn't see that boundary until I had a tool that didn't share the assumption. So I built something that lets anyone rename and restructure to their heart's content while the correctness work stays intact, because correctness was never about where things are or what they're called, it's about being able to pull them and verify them wherever they live, whatever name they carry. The naming problem is gone, and I mean gone, not solved, because it was never a structural problem, just an answer dressed up as a question. It was a 2+2, and I stopped asking it.

Three teams organize the same sales data completely differently:

One organizes by rep and calls the quantity "qty" in JSON, another organizes by date and calls it "units_sold" in YAML, a third organizes by customer account and calls it "volume" in CSV. The system doesn't care, because config maps each field to its structural role and the query asks for roles, not names. An AI reading any of these might say "John Smithers sold 3000 cars to Gina Joon," and if what I need to know is that John sold 3000 to Gina, the hallucination happened entirely in parts I don't depend on. The structure I care about held.

You don’t need the guy who coined it

If you're reading this as "congrats, you built a configurable pipeline," you pattern-matched the output and missed the input. I wasn't staring at a naming problem. I was working through how you build correctly in a probabilistic world, where everyone has a different answer for the same question and different words for the same answer, and this decomposition is one insight of many that fell out of that work. Most people never get there because they're using AI to generate answers instead of using it to find the questions.

And the proof that the questions matter more than the answers is that people keep finding the same ones independently. I've converged on several things that already have names and disciplines, context engineering, AI labeling, what Karpathy calls autoresearch, building my own versions with my own words, and I only found out recently because someone shared a post in our team Slack. Colleagues have told me the same happened to them, and we've compared systems that do the same thing under different names. It isn't new for me either: I arrived at the ideas behind hexagonal architecture before reading about it, and at something very close to calm technology before hearing the term. Not because I'm special, but because the problems are real and the practice leads you there if you follow it far enough.

This has always happened. Newton and Leibniz invented calculus independently, Darwin and Wallace both arrived at natural selection, and history is full of deeply applied people converging on the same insights without coordinating, because the structure is real and discoverable by anyone rigorous enough to reach it. What's new is that AI gives everyone who cares to try the power of being that applied. The engineers saying "AI can't replace me because a vibe coder doesn't understand architecture" are missing this completely: AI lets anyone derive their own version of architecture, one that solves the same issues and optimizes for what that person actually cares about. You don't need the person who coined "autoresearch" to find autoresearch. Find the problem and you'll find a way to solve it, and it may be the same thing under a different name, and you may never know, and it doesn't matter.

Which doesn't mean the literature is worthless. The named disciplines aren't worth reading for authority, they're worth reading to import the failures someone else already paid for, so you don't rediscover them the expensive way. That's the only thing a citation buys you that your own derivation doesn't: other people's scar tissue.

So the system I'm building scales down on AI, not up. Every question that turns out to be a 2+2 gets encoded and stops being asked, which means one less place a hallucination can leak into outcomes, and AI gets pointed at the frontier instead, the space without a clear path, around a base that stays correct without inference. Some days I can't help feeling we're getting a small piece of the Star Trek society out of this, where exploration becomes the incentive.

Keeping invariants falsifiable

The dangerous failure in all this isn't hardening too little, it's hardening wrong. When you encode a question you stop asking it, and when you stop asking you stop noticing, so the system can keep confidently returning an answer inside a model that went stale. The tests guarding the encoded parts can't save you there, because they only catch divergence from the pinned answer, and the pinned answer is the thing that went stale. So the real design problem isn't how to harden, it's how a hardened invariant stays falsifiable after you've stopped looking at it.

My answer is that everything outside the base is allowed to break, and has to break loudly, an idea I've been calling lessons, not errors: a failure should carry the context needed to fix it, and the system should have a protocol for integrating what it teaches, so breakage feeds the design instead of just interrupting it. I take shortcuts out there, I leave things rough, and when something breaks, that's the moment I decide whether I care. Sometimes the invariants held and the breakage is in a part I don't care about. Sometimes it reveals a question I hadn't found yet, a new 2+2 to encode. And sometimes loud failures in the don't-care zone start implicating something I'd already hardened, which is the radar telling me an old 2+2 stopped being one. Those lessons do double duty, they're where I find the next thing worth encoding and they're the early warning that an encoded answer went stale. The one failure this can't metabolize is the silent one, because it doesn't give the right answer and it doesn't teach anything, so it never triggers the decision of whether you care, it's the one failure with no lesson in it. If anything out there fails quietly, the loop stops being honest.

The classification gets no immunity either. Calling something structure instead of an answer is also an answer, and it can be mis-hardened like any other, so the frame has to be willing to eat its own classifications.

The loop

So it loops: AI finds structure, the structure gets encoded, the system gets more deterministic, and AI moves to the next frontier, each turn trading work that never needed intelligence for work nothing else can do. What counts as 2+2 depends on the model being applied, and models evolve, so a system that can only harden is brittle, and a system that never hardens is AI all the way down, praying nothing goes wrong.

I don't know what this looks like finished. I'm building it and finding out. But stop asking AI what 2+2 is. Make it not a question anymore, and point everything you freed at the questions that will never have a lookup table.