Production AI in E-Commerce, China's AI Grid, and Why Visual Programming Might Actually Have a Future
Published on 16.06.2026
What Production AI Looks Like Inside a Large E-Commerce Business
TLDR: A practical case study on deploying AI in a real e-commerce environment, where the first meaningful AI project wasn't a chatbot or a recommendation engine but something far less glamorous that actually worked in production.
Summary: There's a recurring pattern in honest accounts of production AI work: the demos that look impressive are rarely the ones that survive contact with real data and real users. The author's first AI project that changed how they thought about automation didn't chat with customers, didn't recommend products, and didn't make the website feel more "intelligent" in any obvious way. Yet it worked. That tension between what AI looks good doing and what AI actually does reliably in production is the subject of this piece, and it's one that most conference talks and vendor case studies carefully avoid.
The e-commerce domain is a useful stress test for AI precisely because the failure modes are expensive and visible. A recommendation system that surfaces the wrong product loses a sale. An automated search system that misranks results doesn't just frustrate users, it directly affects revenue in ways that are easy to measure. The author's experience points toward a more careful, less ambitious approach: start with the boring automation that nobody wants to demo, prove it works in production, and only then expand. Search is described as a hard place to start, which makes sense because search quality is nuanced and the evaluation criteria are contested. The article argues that the actual shape of production AI work is less about frontier models and more about data pipelines, evaluation frameworks, and the unglamorous work of measuring whether the thing is actually doing what you intended.
What's missing from this framing is a serious engagement with the organizational dynamics that usually kill production AI projects before they reach the "boring automation that works" stage. Companies run pilots that get great demo results, then struggle to operationalize because the people who built the model are different from the people who maintain the system. That gap doesn't get discussed here, and it's often the real reason production AI fails.
Key takeaways:
- The most durable production AI projects often start with automation that isn't exciting to demo but solves a real operational problem.
- E-commerce is a useful proving ground for AI because success and failure are directly tied to revenue metrics.
- Evaluation frameworks matter as much as model quality; knowing whether the system is working correctly is a harder problem than building the system.
- Starting with search as a first AI project is often a mistake because search quality evaluation is genuinely difficult.
Why do I care: The pattern the author describes, starting small and boring and building from there, is the right approach and it's consistently undervalued in organizations excited about AI. I've seen too many projects where the team spent months on the impressive-sounding use case and then discovered they couldn't measure whether it was working. The unsexy work of building evaluation infrastructure first would have saved all of it.
What Production AI Looks Like Inside a Large E-Commerce Business
China National AI Grid Targets 80% Domestic Tech Amid Compute Chokepoints
TLDR: China is building a national AI compute grid with an explicit target of 80% domestic technology, a direct response to US export controls on Nvidia chips that have created real compute shortages for Chinese AI development.
Summary: The story of China's national AI compute strategy is ultimately a story about what happens when export controls force a country to vertically integrate faster than it otherwise would. The 2 trillion yuan data center initiative is large by any measure, but the more interesting number is the 80% domestic technology target. That's not just a procurement goal, it's an acknowledgment that Huawei's Ascend chips and domestic interconnects need to be production-ready at scale, and that the window for running foreign-sourced compute infrastructure is closing deliberately.
Nvidia's export control workarounds, the various H20 and downgraded architectures that were legal at different points, represent a cat-and-mouse dynamic that China's AI sector has been navigating in real time. The compute chokepoints are real: training large frontier models requires the kind of high-bandwidth memory interconnects that Nvidia's restricted chips either lack or provide at reduced efficiency. The national grid initiative is a bet that if you build enough domestic infrastructure and force enough adoption, you can close the performance gap through scale and optimization even if the underlying chips are less capable.
The article doesn't seriously engage with the timeline risk here. Building a domestic semiconductor and interconnect ecosystem at this scale while simultaneously deploying it for frontier AI training is an enormous engineering challenge. The assumption that you can hit 80% domestic technology and maintain competitive AI capability at the same time requires both the hardware supply chain and the software optimization stack to work well together, and there's limited evidence that either is at that level yet.
Key takeaways:
- China's 2 trillion yuan national AI compute grid targets 80% domestic technology as a direct response to US export controls on Nvidia GPUs.
- Huawei's Ascend chips are the primary domestic alternative, but closing the performance gap with restricted Nvidia hardware at frontier model scale remains a major challenge.
- The national grid represents a state-level bet on domestic semiconductor self-sufficiency that forces the ecosystem to mature at a faster pace than market forces alone would produce.
Why do I care: This matters for anyone thinking about AI infrastructure at a global level. The compute geography of AI is being shaped by export controls, not by technical merit. That's going to produce fragmentation in model availability, model quality, and training methodology that will affect the whole ecosystem. If you're making technology choices that assume access to the same compute infrastructure globally, that assumption is already wrong.
China National AI Grid Targets 80% Domestic Tech Amid Compute Chokepoints
Why the Next Programming Paradigm Has to Be Visual
TLDR: The argument is that AI has created three problems that text-based code cannot solve, and that visual programming languages address all three by design, making VPL the natural successor to text-based programming.
Summary: This is a claim that gets made periodically, and it usually fails to land because the people making it underestimate how much of programming's value is in the precise, structured text that humans and machines can both read and manipulate. The argument here is that AI-generated code creates problems around comprehensibility, maintainability, and verification that visual representations would solve by making the structure of a program more immediately apparent.
The strongest version of this argument is about legibility. When an AI agent generates several hundred lines of code to solve a problem, the engineer reviewing it has to mentally execute that code to understand what it does. A visual representation could make the data flow and control flow immediately apparent in a way that textual code, especially AI-generated textual code that lacks the human-readable structure of carefully written programs, does not. The author's Pipe programming language is an attempt to build this general-purpose visual language, which means we're in territory where the idea is being tried rather than purely theorized.
The weak version of this argument, which is what usually gets presented, is that visual programming is just more intuitive. That claim has been made and refuted many times. The actual advantages of visual programming are narrow: certain domains, like data pipelines, state machines, and audio/visual processing graphs, genuinely benefit from visual representations. General-purpose software development has resisted visual approaches for forty years, and the structural reasons for that resistance, expressiveness, abstraction, and tooling, haven't changed because AI now generates more of the code.
Key takeaways:
- AI-generated code has reduced the value of text-based code as a human communication medium, which is the strongest actual argument for visual alternatives.
- Visual programming has genuine advantages in specific domains like data pipelines and state machines, but has not succeeded as a general-purpose paradigm despite decades of attempts.
- The tooling ecosystem around text-based code represents enormous accumulated investment that visual programming would need to replicate or replace.
Why do I care: I'm skeptical but paying attention. The argument I haven't heard answered well is: if AI is writing most of the code, and humans are primarily reviewing and directing rather than writing, maybe the optimal human-facing representation isn't the same as the optimal machine-generation representation. That's a genuinely interesting question. But the specific answer "make it visual" has a weak track record.