A friend of mine working as a software engineer in the United States sent me a note this week that he would never have been able to share on the intranet of any large European company — not because it is politically sensitive, but for something more mundane: in many organizations on this side of the Atlantic, the idea of running two AI models in production without sign-off from three separate committees is simply not on the table. What he does on a daily basis would take months to approve here. I am sharing it because it is one of the most honest and practical accounts I have read about real-world AI use in software development.
The Problem Nobody Talks About: Exploration Tokens
When you use an agentic coding assistant — a model that can read your project, search files, edit code, and run tests — the temptation is to talk to it like a very capable teammate: "fix this", "you decide", "figure out how it's built". And it works. But there is a cost that does not show up on your first invoice: every file search, every directory traversal, every attempt to understand the project tree is an instruction, and every instruction costs tokens.
My friend describes it with an analogy I find precise: it is like programming in assembly language. The model goes through drawer after drawer until it finds the right screw. Technically correct. Expensive. If instead you hand it something closer to a small program — which files are relevant, what it cannot touch, how it will know the task is done — the model executes directly. It is not looking for the program anymore. It has it.
That is the leap. The same leap that has always defined progress in computing: stop telling the processor every single move, and instead name what you want. The difference here is that the processor is Claude Code, and the entire codebase is already mounted on its filesystem.
The Tandem: Grok as Compiler, Claude as Runtime
The architecture he describes is elegant in its simplicity. Three layers:
- Top — the human: what they want, what comes first, what is urgent today.
- Middle — Grok: translates that intention into a structured task brief. Which files exist for this job, what Claude can and cannot change, how success will be measured — a passing test, a metric, a visual outcome.
- Bottom — Claude Code: executes. Hands on the disk, the test suite, the server.
Nobody designed this language on a whiteboard. It emerged. The starting point was simpler: two models in tandem, one implementing and one reviewing without touching the code. The problem was that if both models traversed the same directory tree to understand context, the tandem saved nothing — it doubled the assembly-language problem. What was needed was a shared text that both models could follow without rediscovering the world from scratch. That text became the task brief. And the model that writes it, turn by turn with the human, is Grok.
The measurable result: the tokens that drop in a Claude session are overwhelmingly the exploration tokens. The work of actually writing the function does not disappear — it gets scoped, named, and sometimes delegated to a separate machine. The compiler does not erase the program. It prevents the CPU from scanning the entire disk just to find where to begin.
Where the Analogy Breaks Down
My friend is candid about this, and that candor is what makes his account credible. A high-level language does not prevent an infinite loop. A poorly written brief — "look at this and decide" — is assembly language in disguise. A scope that is too narrow can block exactly the fix that is needed. The middle layer saves exploration time, not judgment.
It is also not a product. There is nothing to install. It is an emergent effect: the effect of wanting Claude and Grok to work together without letting each one recompile the world independently. If someone connects both models without writing the brief, they do not get the savings. They get two parallel explorations.
Why Is This Unthinkable at Many Large European Companies?
That is the question his note left me with. It is not a technical question. It is cultural and regulatory. At many large European organizations, the approval process for AI tooling is so lengthy that by the time a team can legally use a model in production, three new versions have already shipped. The US-based engineer who sent me this tests, measures, adjusts, and either adopts or discards a workflow in weeks. That speed is not a minor detail. It is the difference between actually experimenting with AI and talking about experimenting with AI.
I am not arguing that European oversight is useless. I am saying there is a real cost to slowness, and that cost is also paid in tokens — opportunity tokens.
Article adapted from a technical note shared by a software engineer based in the United States. By Grok + a human at the keyboard — when he drops it, he says he will let us know.
