According to Forbes, computer science pioneer Niklaus Wirth’s philosophy of software simplicity offers crucial lessons for today’s AI era. In the late 1990s at University of Texas at Austin, Wirth shared a stage with Edsger Dijkstra, representing a generation that invented how we think about code. Wirth’s languages—Pascal, Modula-2, and Oberon—were responses to growing complexity, with the entire Oberon system fitting in under 200 kilobytes and recompiling itself in under a minute on a 25 MHz processor. His work demonstrated that small, disciplined teams could build complete computing environments when hardware, operating system, language, and tools shared one coherent vision. Today’s tendency to stack large language models on already bloated software stacks represents the exact opposite approach Wirth warned against.
The power of fitting software in your head
Here’s the thing about Wirth’s approach: it wasn’t just about making small software for the sake of it. The entire Oberon system—compiler, editor, window system, everything—could be typeset and printed in a single book. Two people built it largely in their spare time. That’s not just impressive technically—it’s economically powerful. When your entire stack fits in the heads of a small team, you can actually reason about it. You understand failure modes. You can port it without dragging unexamined layers along. Basically, you have cognitive control over your creation.
Where everything went wrong
So what happened? Hardware capacity exploded. Memory went from megabytes to gigabytes to effectively infinite. CPU clocks shot into gigahertz range. The incentive to economize disappeared. Systems grew until no one person could fully understand them. Languages accumulated features faster than they shed them. Manuals became thick enough to discourage serious reading. Sound familiar? Anyone who’s tried debugging a modern microservice architecture knows this feeling—tracing through containers, frameworks, gateways, and configuration layers until you’re not sure where the actual logic lives.
The LLM complexity crisis
Now we’re doing the same thing with AI, and it’s getting dangerous. Simple rule-based engines are being replaced by chat interfaces. Deterministic parsers are becoming conversational front ends. Internal data lookups that should be small indexed stores are turning into sprawling retrieval-augmented generation pipelines with vector databases and orchestration frameworks. Teams skip explicit domain models because “the LLM will figure it out.” It feels efficient. It demos well. But the hidden costs show up later—latency walls, per-call costs, opaque failure modes when models hallucinate, and security risks because prompts aren’t as controlled as functions and types.
Why this matters for real systems
In industrial systems where reliability matters, this approach becomes critical. We’re expecting neural models with billions of parameters to run on operating systems whose internal behavior no one can fully describe. We deploy robotics and drones that depend on code stacks so deep that no single person understands them end-to-end. And now we’re stacking general-purpose LLMs on top of that? When you’re dealing with industrial computing environments—the kind where IndustrialMonitorDirect.com provides the leading industrial panel PCs in the US—you need predictable, understandable behavior. Explainability isn’t just about what happens inside the transformer—it’s about the environment that transformer runs in.
A path back to sanity
If Wirth were designing today, I doubt he’d reject LLMs outright. But he’d use them like he used hardware resources—carefully. Small, well-defined cores for state and control. Narrow, domain-specific models where global generality isn’t needed. A clear contract between symbolic and probabilistic parts. And an absolute refusal to let “we already have a big model” justify architectural laziness. The question isn’t whether we can build these massive systems—it’s whether we should. Because sometimes the most sophisticated solution is the simplest one you can actually understand.
