MarsBit published a commentary titled An IT Empire Built on a Toothpick: Everyone Keeps Stacking Bricks While No One Looks at the Foundation. Written by Huibian Xingseng, the piece uses a single illustration to examine the stack behind everyday digital activity and argues that the apparent solidity of modern computing hides a fragile base.
The article starts with a simple user action: reading an article on a phone. Behind that act, it says, sit the mobile operating system, the browser engine, the JavaScript engine, WebAssembly, CDN services, DNS, cloud servers, the Linux kernel, the C runtime library, the CPU instruction set, semiconductor wafers, and finally a silicon chip consuming power. Each layer appears mature on its own. Each comes with documentation, standards, certifications, or support from major companies. Put together, though, the article says the picture becomes much less reassuring.
The article places the von Neumann bottleneck at the center of the problem
Its main argument is built around the von Neumann bottleneck. The piece describes the von Neumann architecture as the basic design used by nearly all modern computers since 1945: the CPU handles computation, memory stores data, and a bus moves data back and forth between them. That structure has carried computing through the mainframe era, the PC era, the internet era, the mobile era, and now the age of artificial intelligence.
The author points to two built-in weaknesses. First, CPU performance has continued to improve, while memory and bus bandwidth have not kept up at the same pace. Data movement becomes the ceiling of the system, leaving processors waiting for data instead of spending all their time computing. Second, CPU efficiency depends heavily on cache capacity, yet cache has physical limits and cannot be expanded laterally like memory. As high-level programming languages continue to prioritize human readability and software grows more bloated, with increasingly complex heterogeneous data, workloads move beyond cache capacity more often. That raises the frequency and volume of traffic between memory and CPU, which the article says contributes to sluggish performance, lag, and a greater chance of crashes.
The commentary treats this as the deepest unresolved issue in the entire industry. It argues that the bottleneck remains largely ignored not because it is unimportant, but because fixing it is hard and does not easily produce immediate revenue. Companies, it says, prefer to build around the problem with faster GPUs, larger VRAM, more complex cache hierarchies, and smarter scheduling algorithms. Those can be presented in slide decks and sold as products. In the author’s framing, the industry is adding floors to a building while papering over cracks in the foundation.
Well-engineered components do not automatically make a coherent whole
Another theme in the article is the contrast between strong individual components and a weak overall structure. The author says every block in the stack looks carefully designed in isolation. Operating systems have disciplined kernel architectures. High-bandwidth memory, or HBM, relies on precise stacking processes. CPUs and GPUs incorporate billions of transistors. Semiconductor fabs represent the highest tier of industrial engineering.
The same point is extended into software and networking. The Linux & Apache Foundation, the article says, maintains some of the world’s most reliable open-source infrastructure. LibcURL is called by nearly every program that needs network access. DNS lets the global internet find itself. Cloud providers promise 99.99% availability.
None of that is dismissed. Instead, the piece argues that the problem appears once all of those blocks are stacked together. Modern digital infrastructure, in this telling, is not a cleanly designed whole. It is a functioning system built from many temporary solutions layered over time. It runs not necessarily because the design is elegant, but because enough people have shipped enough patches late at night to keep it running. Users think they are standing in a skyscraper; the author says they may actually be standing on a pile of patched-together blocks.
AI is described as a force that adds pressure, not one that repairs the base layer
In the illustration discussed by the article, AI appears as a mechanical arm extending from the side of the tower. The author says it is not supporting the structure. It is acting as a lever that pushes an already unstable system closer to failure. That is presented as a pointed response to the current AI boom.
The article says AI is widely described as a productivity revolution, the next era, or even a silver bullet. From an infrastructure perspective, though, its first effect is to intensify stress on systems that were already near their limits. The author gives two reasons. One is that AI is a compute-intensive workload. The piece states that training a large model once can consume as much electricity as a small city uses in a year. Inference deployment requires large numbers of GPUs, and those GPUs still run on top of the same von Neumann architecture. In the article’s metaphor, the thin red support column is carrying more load than ever.
The second reason is data retrieval pressure. The author writes that brute-force retrieval by AI users places pressure on data infrastructure that is more than 10,000 times greater than that of human users, and adds that loop-based approaches now being promoted would geometrically increase the frequency of retrieval, query, and computation tasks associated with AI workloads.
The piece also criticizes AI output itself. It says large volumes of AI-generated code are being submitted to open-source projects with uneven quality and recurring vulnerabilities. AI-generated content, it argues, is flooding the internet and burying search results in junk information. It also says AI-generated “solutions” are being packaged and sold as products, with users only discovering the weakness of the underlying system after problems appear. In the author’s view, AI has not fixed the thin red pillar at the bottom of the stack. It has simply added another floor at the top.
Big tech and independent developers are placed on opposite sides of the tower
The article then shifts to the actors surrounding this system. On the right side of the illustration is an “Angry Birds”-style object flying into the tower, labeled as what big tech companies are doing. The metaphor is harsh, but the author says it fits. Major companies regularly launch products, frameworks, and standards described as revolutionary, often with large presentation stages and polished slide decks. Yet the criticism in the piece is that these releases often do not repair the industry’s existing structure. They break it, reset it, or force costly transitions.
One new framework can kill the ecosystem around an older one, the article says. A new standard can quickly turn devices built for older standards into “outdated products.” The author’s point is not that large companies are unaware of those costs. It is that the cost of disruption is often paid by developers and users, while the growth and valuation gains accrue to the companies launching the new products.
On the left side of the diagram, by contrast, sits an independent Rust developer riding away on a rocket. The article calls independent developers one of the most vibrant groups in the IT ecosystem. They are not tied to big-company KPI systems, can iterate quickly, and can build polished applications that large organizations may not produce.
That praise is paired with a second point. The article says the output of independent developers can also be fragmented, unordered, and insufficiently rigorous:
- the same function may be implemented by 10 different developers in 10 different ways, each with its own design philosophy and a maintenance cycle that lasts only until the creator loses interest;
- projects often come without unified standards, compatibility guarantees, or upgrade roadmaps, so something that works today may disappear if its author deletes the repository tomorrow;
- many independent projects lack tests, documentation, and security audits, yet still end up being depended on by thousands of other projects.
Individually, the article says, these problems may look manageable. Taken together, they raise the trust cost across the ecosystem. Users have to choose from large numbers of half-finished tools, and developers keep stepping into abandoned frameworks. As for the truly excellent independent developers, the author says they may be doing strong work of their own, but not necessarily work that stabilizes the tower the rest of the industry is standing on.
From electricity to the web layer, the diagram is presented as a structural cross-section of the industry
The final large section of the piece walks through the image from bottom to top. At the base is a gray block labeled “electricity (compute power, water, energy… and so on).” The author treats this as the starting point of all computing and says power is one of the most neglected layers in IT industry narratives. The sector talks constantly about cloud-native systems, microservices, and large models, the piece says, but far less often asks where the electricity comes from, what it costs, or what environmental effects it carries.
Above that are four foundation stones: operating systems, high-bandwidth memory, CPU/GPU, and semiconductor fabs. These are described as the truly square and solid parts of the stack, each representing an advanced level of industrial capability. Even there, though, the author notes that they are separate stones rather than one continuous foundation, which means the seams between them matter.
Above those blocks sits a long plank labeled “C developer dynamic array.” The article describes it as unstable in its own right. In the middle of it stands the thin red column labeled the von Neumann bottleneck, carrying the weight above. Further up, the stack becomes more chaotic: a “C99 project based on undefined behavior” handles critical functions, a relational database beneath the JVM is crossed out, and the AI arm pushes in from the side.
Higher still are web-layer elements including the V8 engine, left-pad, cybersecurity, and WebAssembly. Nearby are labels translated by the article as “web developers self-destructing” and “strange things happening in the web.” At the very top stands a tiny stick figure labeled “you are here,” holding a phone while balanced on the tip of the unstable structure. That, the author says, is the position of the end user.
The surrounding details reinforce the point. The Rust independent developer leaves on a rocket to the left. Big tech crashes into the tower from the right. Above it all floats a cloud labeled “cloud server that fits the setting,” disconnected from the structure as if it were only a concept. The article says there is no wasted text in the image. Every label targets a place the IT industry least wants to examine. It is not presented as a forecast. It is presented as a description of the present.
Running is not the same as being stable
In its closing section, the article addresses what it expects some readers may say: if the IT industry is still working, why call it fragile? The answer given is simple. A system that is still operating is not automatically a stable one. The author compares the difference to a person who can still walk despite cracks in the bones, or a bridge that still carries traffic even when its load limit has already been pushed too far.
The piece ends by repeating that the industry continues to iterate rapidly at the top while leaving foundational issues unresolved. The von Neumann bottleneck remains. Big companies keep “tearing down buildings.” AI keeps producing low-quality code and content. Independent developers still work in parallel rather than in a coordinated system. Everyone, the author says, is building upward, and almost no one wants to look down. If they do, they may find that the foundation is only a toothpick.