Note: This article is a developer-focused adaptation of my original blog post in Italian. You can read the full, in-depth personal reflection here: La storia si ripete? on Nospace.
Every time we transition through a major technological shift—from the steam engine to personal computers—we witness the exact same arena. One side screams about imminent miracles, while the other predicts the end of human work. Today, with the artificial intelligence hype cycle at its absolute peak, we are watching history play out on fast-forward.
If we look back, the script never changes. From the taming of Fire that altered our biology, to the Agricultural Revolution that anchored us to the land, through the Age of Metals, the industrial muscle-multipliers of the Steam Engine, and the information storage of the Personal Computer—each leap has split humanity into fierce believers and doomsday prophets. Now, as we enter the Noetic Revolution (or Cognitive Era)—where tech no longer just replicates our muscles but directly targets our cognitive processes—the cycle begins anew.
Let me be clear: these are my personal opinions, born from daily battles in the software engineering trenches, looking at messy real-world systems, and refusing to drink the Silicon Valley Kool-Aid. This isn't doom-and-gloom pessimism. I build systems for a living; I know technology is a fantastic utility. But as engineers, our job is to apply healthy skepticism and debug the hype.
If you were around during the PC boom of the '80s and '90s, you’ll probably recognize the tune the industry is playing right now.
1. From the "Wintel" Spiral to the GPU Loop
If you programmed or worked in IT during the '80s and '90s, you surely remember the Wintel (Windows + Intel) alliance. It was a perfect, self-serving commercial spiral: Intel manufactured increasingly powerful and expensive microprocessors; Microsoft and other software giants responded by releasing heavier, more resource-hungry operating systems and programs (the classic bloatware).
At the end of this chain sat the customer—often a confused business owner—forced into a perpetual hardware upgrade cycle just to run software that ultimately did the exact same tasks as before, like writing documents and filling basic spreadsheets. It felt like an endless loop, but it eventually hit a physical and economic ceiling.
Today, the players have changed, but the playbook is identical:
- Nvidia acts as Intel, holding a chokehold on high-end GPU hardware (and charging eye-watering prices for the privilege).
- OpenAI, Anthropic, Google, and Microsoft are the new Microsoft, shipping increasingly resource-hungry models that require massive server infrastructure just to generate text.
They tell us we are on the verge of AGI, but the business model is exactly the same: push more expensive silicon to run heavier, heavily subsidized software that often struggles to deliver a proportional jump in day-to-day utility compared to the previous release. It is the Wintel bloatware cycle, retrofitted for probabilistic token prediction.
2. The Illusion of the Plateau and "Cooked Benchmarks"
With every new model launch—whether OpenAI releases GPT Astra, Anthropic drops Fable 5.1, or Google demoes a new version of Gemini—we get the same coordinated PR blitz. Look at this benchmark! Look at the leaderboard!
But anyone writing production code daily knows that real-world performance is hitting a visible plateau. The jump from one model version to the next is no longer a paradigm shift. It is a steady refinement of details: slightly larger context windows, a few milliseconds shaved off latency, or cleaner JSON outputs.
These academic benchmarks are increasingly saturated or, worse, "cooked" to look good in marketing slides. In a clean, sterile lab environment, the scores go up. But when these models hit the messy, real-world production trenches—with dirty legacy data, undocumented business logic, and a complete lack of determinism—the magic evaporates.
As tech critic Ed Zitron pointed out in his explosive interview on Steven Bartlett’s *The Diary Of A CEO* (check it out here), the underlying economics are a house of cards. We are seeing massive, circular cross-funding agreements (hyperscalers funding startups so they can spend that money back on their own cloud infrastructure) to keep valuations high, while actual enterprise adoption yields tiny, unprofitable returns. It's a bubble, and the foam is about to blow off.
3. The "Democratization of Error" and the Clean-up Crew
There is a loud, naive narrative—pushed by tech VCs and occasionally echoed even by brilliant creators like Salvatore Sanfilippo (antirez) in his latest video, I smell AGI: Chollet, GPT Astra and Fable 5.1—that software engineering is a dying career. The theory goes that because AI can write code, non-technical business users will soon prompt their way into building fully functional enterprise software all by themselves.
History, however, has already debugged this delusion:
- The '80s Spreadsheet Boom: Lotus 1-2-3 and VisiCalc were supposed to kill the IT (EDP) department. Managers would build their own financial tracking systems! Instead, it created an epidemic of corrupt formulas, silent calculation errors, and terrible business decisions.
- The 2000s WYSIWYG Web Builders: FrontPage and Flash promised that anyone could build a professional website in an afternoon. Developers spent the subsequent decade rebuilding those slow, unoptimized, and unmaintainable sites from scratch.
Lowering the technical barrier of a tool does not lower the cognitive barrier of systems analysis. When non-technical users prompt an LLM to generate code, they produce what I call the Democratization of Error: a chaotic web of unmonitored scripts, silent data corruption, security holes, and massive technical debt generated by people who don't understand system state, database normalization, or security.
We aren't going anywhere. Our role is simply shifting from typing syntax to system architecture, verification, and reverse engineering. Senior developers will become the highly-paid "Architectural Clean-up Crew," hired to untangle the spaghetti messes generated by AI-enabled business departments.
4. Formula 1 Cars vs. Trucks in Medieval Traffic
Why is there such a massive gap between tech visionaries and on-the-ground engineering? I believe it is a matter of scale and perspective.
Some of the most brilliant minds and database designers in our industry naturally think like Formula 1 engineers. They analyze raw telemetry, work on incredibly high levels of abstraction, and assume the entire society can adapt to technological shifts at instantaneous speeds.
But those of us working with real-world organizations and SMEs are driving trucks through medieval streets. You can have a 1,000-horsepower engine under the hood, but if the street is narrow, packed with pedestrians, legacy processes, and rigid regulations, you can only move at a crawl.
Most real-world software complexity resides in constraints that a probabilistic model from OpenAI or Google cannot solve:
- Liability and Legal Responsibility: If a black-box model makes a catastrophic financial calculation for a bank, who is liable? OpenAI? No risk committee will ever authorize replacing deterministic systems with probabilistic ones that have even a tiny margin of unassisted error. An enterprise needs someone to sign off and take legal responsibility.
- The Legacy Monolith (The COBOL Wall): Critical transaction systems often rely on technologies designed decades ago. They might look ancient, but they are incredibly secure and deterministic. Swapping them out for a probabilistic agent workflow is a risk no prudent manager is willing to take.
- Psychology and Ego: Software engineering is rarely just about translating specifications. Often, the client doesn't actually know what they need. Furthermore, models are trained to be highly compliant "Yes-Men." If a manager asks an AI to automate an inefficient, poorly designed business process, the AI will happily generate the code in seconds, automating chaos at the speed of light. A human engineer has the experience to stand up and say, 'No, we need to redesign this workflow first; then we can automate it.'
Conclusion: Our Value Isn't in the Syntax
The current hype cycle will eventually transition into a classic, healthy correction. The miraculous, "sentient machine" marketing will fade, and AI will be recognized for what it truly is: a highly useful, specialized, and incredibly productive developer utility for autocomplete, boilerplate generation, and specialized automation.
As developers, our value has never been in typing characters on a keyboard. Our value lies in understanding context, structuring complexity, managing state, and taking responsibility for failure.
The machine owns the syntax and the speed; we own the semantics, the context, and the intention. Focus on system geometry, architectural resilience, and deep analytical skills. When the dust of the hype settles, those will be the only shields left standing.
What is your experience on the ground? Are you already dealing with AI-generated technical debt, or are you seeing real-world productivity gains that justify the massive infrastructure spend? Let's discuss in the comments below!
Top comments (12)
So many quotes to pull from this fantastic article but this one stood out to me "No risk committee will ever authorize replacing deterministic systems with probabilistic ones that have even a tiny margin of unassisted error. " Working in any regulatory sector requires the safety of deterministic systems as sometimes people's lives literally depend on it. There's a saying, "They don't make them like they used to." And to me, this applies in this context. In some use cases, not all, boring determinism is the most hardened and safest strategy that maybe wasn't intended to be built to last necessarily but here we are!
Thank you so much! It really means a lot to hear that—I’m glad I managed to translate my internal chaotic thinking into something clear and relatable!
Your point on 'boring determinism' (and why it will likely never die in certain domains) hits the nail on the head. It’s a debate we’ve been having as engineers long before the current AI wave—we saw the exact same tension back in the '90s and during previous automation shifts. In mission-critical systems, predictability isn't a limitation; it's the whole point.
Definitely! Message received. :-)
I'm with you on predictability. In come cases, AI has helped us shift away from precision. Not always or necessarily a bad thing but there's a certain satisfaction from something being certain.
Really appreciate this post. An analogy that comes to mind when I think about AI is plastic -- useful and life-saving, but way overused to the point of extreme harm, and no accountability. I keep thinking of the pool scene in The Graduate and you can replace it with AI and it's eerily relevant.
Thanks! That plastic analogy is spot-on. Replacing 'Plastic' with 'AI' in The Graduate captures the exact absurdity of today's hype cycle.
It’s fascinating how fast definitions bend for quarterly goals. Hours after my post, Nvidia's CEO claimed 'AGI has arrived'—simply by shifting the definition from human-level reasoning to completing specific tasks.
Between chipmakers declaring AGI is here to sell 400k GPUs, and ex-Anthropic insiders sounding apocalyptic doom alarms, it's all media theater. Both narratives keep the valuation bubble inflated while dodging real-world engineering accountability.
This is so so so true. And it takes the fun out of engineering. It's like everyone's chasing these trends like they're desperate teenagers, and we all get to feel the whiplash.
sounds terrible!
Fair enough! English is not my native language, so sometimes the phrasing gets a bit weird. I was thinking of 'debugging' in terms of looking under the hood line-by-line to understand the chaos. But I agree, using a developer dialect, 'tracing the hype' sounds way better. Consider it noted for my next article!
I meant not an English. But the idea that hype may be traceable or debugged. :) How's that?
Ah, I completely misread your first comment, my bad! 😄
You raise a great philosophical point: can we truly 'debug' something as irrational and emotional as market hype?
From a psychological perspective, probably not—human nature and Silicon Valley FOMO definitely don't follow deterministic logic. But philosophically, we can still analyze the cycles, observe the outputs over time, and see what happens under the hood.
It's a lot like black-box testing: when you don't have access to the source code, you focus on the inputs and outputs to figure out what's really going on underneath. A sort of reverse engineering of the hype, if you will.
We might not fix the bug in human enthusiasm, but we can certainly inspect the stack trace!
I'd underline the liability section. I work in regulated environments, and the question in the room is never whether the model can do the task. The question is who signs the form when it gets it wrong, and a probabilistic system has nobody to put in that box.
Your democratisation-of-error point has a more recent verified example than the spreadsheet boom. In late September 2020, Public Health England lost 15,841 positive COVID test results. Lab results were collected in the old .XLS format, which caps at 65,536 rows, so once the file filled up, new records were dropped. No error, no warning. Roughly 48,000 contacts were never traced, and a peer-reviewed study later estimated the delay was associated with more than 125,000 additional infections and over 1,500 additional deaths.
Nobody prompted an LLM there. That was a spreadsheet doing exactly what it was designed to do, inside a national health system, during a pandemic.
So the problem was never that the tool was bad at its job. The problem was that a failure travelled through a chain where nobody was positioned to notice it. AI does not introduce that failure mode. It widens it.
And the clean-up is harder this time, because AI-generated code looks correct. A bad spreadsheet formula at least looked like a mess. A confidently wrong function with clean naming and a tidy docstring gets through review far more easily.
Spot on, especially regarding the camouflage of AI-generated code: an old spreadsheet error at least looked like a mess, whereas an elegant algorithmic bug hides in plain sight during review. And on the "who signs the form" question—legal liability has no API to delegate to. Thanks for sharing such a fitting example!