The more I build, the more convinced I am that the valuable part isn't on the answer side at all.

Look at the two layers everyone's fighting over. The model layer is turning into a utility — you rent it by the token, and everyone rents the same thing. The app layer is a cloning race: one feature takes off, and someone ships a copy within the week. Long term, neither layer is defensible. You can't build a moat out of something everyone can rent, or something anyone can copy.

So where does a moat actually fit?

In a place almost nobody is seriously working on: the thought you haven't finished having yet.

Every AI tool today stands downstream of "you already figured out what you want." You sort the idea out in your head, translate it into a prompt, and feed it to the machine. We even turned that translation step into a skill with a name — prompt engineering. Which, if you stop and look at it, is backwards: it's the human accommodating the machine. That's not a stable arrangement. It never has been, for any technology.

Upstream of all that is the moment an idea first surfaces — when you couldn't even articulate it to yourself yet. Whoever catches you there decides everything that happens after: which model gets called, which app opens, which path you take. The entire chain downstream gets routed by that first touch.

We've seen this movie. The search box won the internet not by having the best pages, but by owning the first moment of wanting to find something. Own that moment and you distribute everything behind it.

The intent layer is this generation's search box. Whoever owns it takes the biggest piece on the table.

So what is it, concretely? A translation layer: from the fuzzy thing in your head to something a machine can execute precisely. It doesn't belong to any model or any app — it sits in front of all of them. Today that translation is done by hand, by you, and we call it "writing prompts." What I want to do is take that job away from the human and hand it to the machine.

Three concrete bets on how.

One: stop making the human explain. Flip it — let the machine read your context and work out what you're doing. Most of what you want is already written in the thing you're looking at and acting on. You shouldn't have to say it again.

Two: do this where the context is richest. That's why my first move is the browser, not an input method. An IME only knows you're typing. The page knows which box you're typing into, against what content, for what purpose — that's an order of magnitude more signal. At this stage, depth of context beats breadth of coverage, and it's not close.

Three: in the middle you need a component whose only job is recognizing intent — compressing a pile of messy context into one precise, executable intent that everything downstream can run with. That's the core I'm still grinding on myself. I won't pretend it's solved.

And one line I hold hard: the system only goes as far as preparing the intent. Whether to fire it — that last press — is always yours. I'll pave the road right up to your feet. I won't take the step for you.

This one isn't written for people passing by. If you're seriously thinking about where this layer lives and who ends up owning it — I want to meet you. Say hi: lingchong@iterant-ai.com.

First it was prompt engineering — learn to write the magic words. Then, around the middle of 2025, everyone pivoted to context engineering — stop fussing over wording, start filling the context window with the right stuff. Now, early 2026, the word is harness engineering — the layer wrapped around the model: tools, memory, state, error recovery, verification, permissions.

Every time the word turns over, a wave of people panic that they've fallen behind. I've stopped reacting to it. Because the more I build, the more obvious it gets: the word keeps changing and the thing underneath doesn't.

Here's the thing underneath. Whatever you call the tooling, you're always crossing the same gap — from "the AI produced something that runs" to "I'll put my name on this, and if it breaks in production, that's on me." Getting across that gap is the entire job. The new words are just the industry renaming the same crossing, over and over.

So instead of arguing about vocabulary, let me just show you ours — the actual rules four of us use to get across that gap. Almost none of it is clever. That's kind of the point.

First, nothing starts without a finish line. If we can't say what "done" looks like before we begin, we don't begin. Then we keep cutting the task down until each piece is small enough to be verified on its own. And at commit time, a hook fires automatically and runs an informedness check — we call the threshold τ — that makes sure a human actually understands every necessary change in that commit. Necessary, not every line. We don't make anyone re-read the AI line by line; that both distrusts the tool and doesn't scale. The point is to pull the change up to the one layer of abstraction a person should own, and be genuinely clear at that layer.

Second, that threshold slides with the blast radius. A low-risk, easily-reversible change gets a light touch — we lean on fast rollback and let it move. The moment something is irreversible or high-impact — data, billing, permissions, migrations — the threshold goes to the ceiling: higher informedness required, and we cross-check it with a second model on a different base. Speed and safety aren't two different settings here. They're two ends of the same knob, and we turn it by consequence instead of turning it all the way to "slow" or all the way to "gamble."

Third, the hard one: verification has to be independent. Independent means the thing that checks is not the thing that wrote. We stack two layers. The first is you — but only if you're genuinely informed enough about this piece, which is exactly the threshold from the last rule. A human who actually understands the change is the first independent verifier. The second layer is a model on a different base, checking the first one's work. The pattern the industry's settling into right now is roughly this: Claude Code writes, Codex checks. Different training, different blind spots — so the blind spots don't line up, and something actually gets caught. The one thing we never do is let the AI check its own work. Change the prompt all you like; it's still reasoning the same way it did when it wrote the bug, so the blind spot sits there untouched.

There's one part of all this we never hand off. You have to know when to let the AI write and when to specify the technical detail by hand — that judgment is learnable. But the actual logic of the problem, the clear line of reasoning through it — that can't be delegated to a model. That's yours, always.

And there's more than one honest way across the gap. Just among four of us the styles diverge hard. One of us works architect-first: before the agent touches anything, he's already cut the thing into layers in his head and knows where every piece goes — heavy on that first verifier, the informed human. Another is bolder: let the agent build it, see it run, then throw several different models at it to check — heavy on the second verifier, the independent model. I used to think those two were opposites. They're not. They're just different weightings of the same two independent checks. We keep both around. Whatever lands the requirement safely is good AI engineering, full stop.

So what's the actual moat? Not the vocabulary. You may have already noticed the whole thing I just described is what people are now calling harness engineering — a name that only caught fire in 2026, and honestly, we're just starting to figure it out ourselves. I'm not going to pretend we've been doing this all along. prompt, context, harness — and there'll be more words after these. The moat is who can take each new tool and each new name and internalize it fastest into something you can actually ship. Keep up with that — the speed of turning novelty into deliverable work — and you keep up with the whole wave.

If you're wrestling with the same thing — trying to ship AI you can actually stand behind, or just working out your own delivery process and want to compare notes — those are my favorite people to talk to. Say hi: lingchong@iterant-ai.com.