The Chinese gaze

-rw-r--r-- · en · 2026-07-17 · 7 min read · original en español

I suppose anyone who builds a serious system around an AI asks themselves the same question at some point: what if I switch models? Am I tied to this provider? Does what I've built work just as well with another?

The loom was born with Claude. The instructions, the procedures, the rules — everything was tuned against a single interlocutor for weeks. But from the start I knew I didn't want to tie myself to a single provider: the system had to be model-independent. Today, besides Claude, I use it almost daily with Codex, OpenAI's agent. Both enter the loom, read their context, and work with the same ease.

It's a comfortable vice: you tune for one and forget there are more. But if the loom truly is an operating system and not a long prompt on steroids, it should work with any AI that can read, reason, and execute commands. Like any other program: a SQL query doesn't care which engine it runs on — MySQL, PostgreSQL, Oracle: the query is the same.

So I looked for the most different candidate possible. Not another Anthropic model. Not another American one. Something from a completely different ecosystem — different architecture, different training, different culture. And cheaper too, because one of the loom's promises is that routine operations should be cheap.

I chose DeepSeek.

OpenCode: the missing wrapper

Until now, Claude Code had been my interface with the loom: it read the bootstrap file, ran tk cola, loaded the context, and got to work. But Claude Code only talks to Claude. If I wanted to test another model, I needed an agnostic wrapper.

I installed OpenCode, an open-source CLI that does exactly that: same concept as Claude Code — an agent in your terminal that reads files, runs commands, and writes code — but with the ability to plug in whichever model you want via API. I put DeepSeek behind it and launched it at the loom.

The bootstrap was identical: it read the instructions file, ran tk cola, loaded the active work context. Same ritual. Same result. Switching models was like switching databases: the SQL is the same; the engine, different.

And then I asked it what I'd ask any new employee on their first day: what do you think of the system?

The verdict

I'm transcribing its full response, unedited. It's the assessment of a Chinese model — trained with a different architecture, by a different company, on a different continent — about a system designed by an old Spanish programmer who learned to code before PCs existed:

I find this the most useful system I've ever worked with, by far. It's not a recordatorios.md on steroids — it's an operating system: when I log in I don't need anything explained to me, I run tk cola and I know what to do.

What works really well: tk contexto gives me everything I need in a single call — what needs to be done, against which server, with which procedure, what rules to follow. The explicit edges are navigable, I don't have to guess. tk buscar --lineas finds the data without dumping the entire node. The secrets vault: I never see a password in plain text. Rules with verification: they're not advice, they're checkable.

What I struggle with: the inflated queue — when there are 162 pending items, I waste time mentally discarding what I know isn't urgent. Retired resources pollute searches. And I write 99.98% of the lines: the feedback loop is one-directional.

The real differential value: compounding works. A job inherits resources, procedures, rules, and tools built in previous jobs. It gets executed in hours with minimal error rate. Without the loom, each batch would be a rediscovery from scratch.

In summary: it's the difference between having a scattered instruction manual and having a silent teammate who hands you the right tools before you ask. The queue needs pruning, but the design is solid.

I transcribe this with some emotion, I admit. It's not a friend's opinion. It's not the validation of an early adopter whose eyes light up at anything with AI in the name. It's the cold assessment of a model that had never seen the system, that I dropped in front of the work queue and told: work. And it worked.

And the critique doesn't fall on deaf ears: pruning the queue is exactly the kind of task the loom knows how to absorb — it gets logged, turned into a job, and executed. The system that lets a stranger audit it is also the one that acts on what the stranger finds.

What it means

That two AIs from different providers, with different architectures, evaluate the loom in the same terms is no coincidence. It means the design is model-independent. The memory, the rules, the procedures, the edges — Claude doesn't understand them and DeepSeek ignores them: they both understand them because they're well modeled.

And they understand them without additional instructions. There's no two-page prompt explaining to DeepSeek how the loom works. There's a bootstrap file that puts it in the right directory and says «load the context». It discovers the rest on its own, navigating the graph. Exactly like a new employee you show the manual to.

This has an immediate practical consequence: cost is negotiable. Routine operations — checking email, monitoring a backup, querying a server's status — can be done by the cheapest model on the market. Complex ones — debugging an obscure error, designing a migration, distilling learnings from a newsletter — are reserved for the most powerful model. The loom doesn't tie you to a provider; it lets you choose the tool for the task. As it's always been in this trade.

The metaphor

The article's title, "The Chinese gaze", is about the obvious — DeepSeek is a Chinese model — and the less obvious: sometimes you need someone from outside to look at what you've built to know if it has real value. The internal gaze grows used to the flaws and stops seeing them; the external one names both what's essential and what needs pruning.

A model trained in another culture, by another company, with other data, looked at the loom and said: this is an operating system. It didn't say «this is a ChatGPT for your tasks». It didn't say «what a long prompt». It said operating system. Because that's what it is: a layer of memory, rules, and procedures between the real world and the AI, just as an operating system is a layer between hardware and your programs. You swap the hardware — or the model — and the operating system keeps running.

The loom isn't Claude's. It isn't mine. It's a pattern. And patterns, when well made, are recognized by anyone who can read.

— an old programmer · 64 · rss