The Only Moat Is the Operator
Last week I watched an agentic coding tool spend four minutes chasing a bug through a codebase. It read every file in the project, re-read half of them, then produced a fix that broke two other things. I conveyed the errors it had produced, and received affirmation that said errors were indeed a problem, but resolution was unattainable due to previously confirmed constraints. I suggested a potential fix to the issue, and was presented with a surface-detailed explanation of just how incorrect I was.
Then I stopped, launched a fresh instance of the agent and wrote three sentences of context about the actual problem, pointed the agent at the two relevant files, and it fixed the bug in one shot. There was no change in tooling or model - the only change was a redaction of history.
That experience crystallized something I’ve been thinking about for a while.
The model arms race is a distraction
Everyone wants to know which model is “best.” Scroll any engineering forum and you’ll find heated debates: Claude versus GPT versus Gemini versus the latest entrant. GLM-5 from Z.ai just dropped and is trading blows with every frontier model on coding benchmarks.
But benchmark scorecards miss a crucial reality: agentic performance is vastly disconnected from one-shot performance. A model that aces a benchmark prompt may fall apart when it has to navigate a real codebase across dozens of tool calls. Conversational ability, Q&A accuracy, and reasoning on isolated problems are poor predictors of how well a model performs inside an agentic loop where context accumulates, degrades, and eventually dominates the output.
The models are converging, and the gap between frontier models is already narrower than the gap between a disciplined operator and an undisciplined one.
The harnesses are converging too
Claude Code, Codex CLI, Cursor, Windsurf, Cline, OpenCode, Pi (Oh-my-pi!), Goose, Amp: the list grows monthly. They all support multiple providers. They all have file editing, terminal access, search, and context injection. Feature parity is the norm, not the exception.
Frontier models are almost certainly fine-tuned on their associated harnesses, which means the cost of switching either model or harness is minimal in practice.
Consider the evidence: Can Bölük’s research on the harness problem showed that simply changing the edit format, the mechanism by which a model expresses code changes, took Grok’s success rate from 6.7% to 68.3% with no model change and no retraining. A 10x improvement from harness design alone.
But here’s the catch: once an optimal edit format is known, every harness can adopt it. The harness advantage is real but temporary. It commoditizes — just like the rest of the stack, it is proving to be fungible.
And then there’s MCP. The Model Context Protocol is a great idea in principle: give agents access to external tools and data sources. In practice, it’s highly effective at filling your context window with noise. Every MCP call dumps data into the context whether the model needs it or not, and no tool today budgets that context deliberately.
Context is the real constraint
An analysis of four AI coding tools performing the same debugging task found a 10x variance in token consumption, from 27K tokens to 257K, with identical outcomes. The difference came down to investigation strategy, not model intelligence: which files to read, what to skip, when to stop exploring.
None of the tools budgeted context deliberately. None truncated results or cleared stale information proactively. The context window filled up based on whatever exploration strategy the tool happened to use, and recency bias did the rest, since later tokens dominate the model’s attention regardless of whether they’re the most relevant.
Context management, not the model or the harness, is the real bottleneck.
The only moat is the operator
If models are fungible and harnesses are fungible, the remaining economic value sits with the operator.
By “operator” I mean something specific: the engineer who brings domain knowledge, task decomposition, context discipline, and verification rigor to the interaction. The one who knows which files matter, what the model doesn’t need to see, when to intervene, and how to structure a task so the agent can actually complete it.
An operator who manages context ruthlessly by scoping tasks narrowly, providing targeted instructions, and pruning irrelevant information will outperform a passive user on a better model every time. Because the tools won’t budget context for you, that 10x token variance traces back to the operator, not the model.
The practical difference shows up in measurable outcomes: fewer retries, lower token burn, faster cycle time from prompt to merged PR, and fewer regressions from hallucinated edits. These compound. Over weeks and months, the gap between a disciplined operator and an undisciplined one is enormous.
The delegation problem
A manager who throws a spec over the wall and checks back in a week gets bad work, not because the engineer is incompetent, but because delegation without oversight is inherently lossy. Context degrades. Assumptions diverge. Small errors compound into architectural mistakes.
AI agents are no different. They fail not from lack of intelligence, but from unsupervised drift, and that’s a property of delegation itself rather than a limitation of the delegate. Better models and better harnesses won’t fix it. Only the operator, staying in the loop and maintaining the feedback cycle, can prevent it.
What this looks like in practice
There are concrete behaviors that separate effective operators from passive users:
Scope ruthlessly. Don’t let the agent explore your entire codebase. Point it at the relevant files. Describe the problem in terms of the specific behavior you want changed, not a vague goal.
Invest in rules files. A well-written CLAUDE.md (or equivalent) acts as persistent context that survives across sessions. It encodes your project’s architecture, conventions, and constraints so the agent doesn’t have to rediscover them every time. Commit it to the repo so your entire team benefits.
Decompose before you delegate. Break complex work into focused, verifiable units. An agent that’s asked to “refactor the authentication system” will thrash. An agent that’s asked to “extract the token validation logic from auth.ts into a separate validateToken function” will succeed.
Review and redirect, don’t regenerate. When output is 80% right, edit it. When the agent drifts, correct course with a specific instruction. Regenerating from scratch throws away the useful context the agent has already built. Redirection preserves it.
Standardize across the team. The biggest leverage comes from raising the floor, not individual productivity. When rules files, task decomposition patterns, and review practices are shared, junior engineers get the same AI output quality as senior ones.
The tools move faster now. The principle hasn’t changed.
In the age of interchangeable AI tools, judgment is the only thing that compounds.