Scroll through LinkedIn or read the tech press these days and you might think the AI utopia has already arrived. Every day a new AI tool, or “version x” of an existing one, gets paraded through the digital village, supposedly multiplying our productivity tenfold, taking tedious work off our hands and, while it's at it, dashing off a poem in the style of Goethe.
Reality is less glamorous: we are stuck in a gigantic proof-of-concept loop. Many systems are technically still immature, many products took a wrong conceptual turn – and all of us, almost always without being asked, have become participants in a global beta test.
How did this happen?
The legacy of “Social IT”: Move fast, break things (and let the user fix it)
To understand why today's AI tools so often feel half-baked, we need to look at who builds them. The tech giants and startups of Silicon Valley are by now culturally rooted deep in the “Social IT” paradigm of the last 15 years – the era of Web 2.0, mobile apps and social media.
The dominant mantra of that era: “Ship it and see what happens”. You throw unfinished software onto the market, give it grandiose names like “Copilot” or “Opus”, sprinkle in a bit of gamification and use millions of consumers as unpaid quality control. If a photo filter app crashes, the user just swipes on. Nobody gets hurt, no supply chain collapses.
Now even “professional” software vendors like Microsoft are applying exactly the same consumer logic to artificial intelligence – a technology that is changing the foundation of our future industrial and economic infrastructure. AI tools are currently being built and dumped on the market like the next dating app.
The head-on collision: “The Great IT Divide”
This careless “Social IT” approach slams full force into the hard reality of the corporate world. As my article
The Great IT-Divide: Why AI-Adoption in enterprises is failingIT innovation moved from business tools to social tech, creating two distinct IT worlds: Business-IT (compliance, efficiency) and Social-IT (social interaction). Grasping this divide is crucial for enterprise adoption and explains why businesses struggle with AI uptake.DocIsInDaHouse
describes in detail, we keep running into this fundamental divide:
On one side stands traditional enterprise IT. It is deterministic. It demands 100% security, compliance, predictability and hard ROI metrics. An ERP system is not allowed to be “creative”. On the other side stands the new AI world: it is probabilistic, experimental and happily hallucinates facts when it doesn't know the answer.
And yet people keep trying to sell the compliance department a probabilistic chatbot that occasionally makes up numbers as the new backbone of accounting. Spoiler: it doesn't work.
The escape into the PoC trap
Because these two worlds don't fit together, and because in many cases AI does not yet meet the hard requirements of “production readiness” in the enterprise sector (scalability, data protection, reliability under load, etc.), the tech industry escapes into “proofs of concept” (PoCs).
A PoC is by definition a protected space. It shows that something works in principle – under controlled conditions, with curated data, without real load, without real damage. The problem starts when PoCs become a permanent state.
Today we have thousands of these impressive prototypes – but hardly a single robust tool you would blindly trust with your annual financial statements.
The conceptual short circuit: AI is (mostly) not a product
To make these PoCs marketable at all, the industry often papers over a design flaw: AI is sold as a standalone product, even though in many scenarios it is more of an infrastructure capability – a feature that belongs inside existing systems.
Instead of accepting that AI should really be a deeply integrated “feature” running in the background of the tools we already use (in the email client, in the operating system, in the CRM), legions of startups are trying to build standalone “products”. They slap a pretty web interface (a wrapper) over the ChatGPT API and expect us to abandon our usual workflows, open 50 new browser tabs and copy-paste our corporate data into their wobbly solutions.
That's not disruption. That's a job-creation scheme.
Congratulations, you're the guinea pig!
And this is where things come full circle. Because the products are still too immature for real enterprise use and are wrongly launched as consumer products (“Social IT”), the tech giants have only one way out: they turn us into guinea pigs.
Since the product managers themselves often don't quite know where the real product-market fit lies, they simply toss the things over the fence and watch what we do with them.
What we are witnessing today is a gigantic outsourcing of product development:
- We train – We pay subscription fees to feed their models with our data.
- We evaluate – Every thumbs up/down is free RLHF (Reinforcement Learning from Human Feedback) for their AI training.
- We compensate – We learn “prompt engineering” to make up for the weaknesses of immature models. We write things like “You are an expert, take a deep breath and think step by step” – as if we were giving therapy to an overwhelmed intern.
The punchline: we even pay for the privilege.
The expiry date of our current “AI skills”
Bad news for everyone currently building a reputation as a “prompt whisperer”: this skill has the shelf life of fresh milk. And in the end it is just as probabilistic as the LLM you're feeding it to.
Caught up in the current hype bubble, we tend to overlook that we are only at the very beginning of a technological innovation cycle – we're more or less in the MS-DOS phase of artificial intelligence. Development cycles are currently so extremely short and volatile that the foundation we want to build on today shifts almost weekly.
Just look at the example of OpenClaw to grasp how unpredictable and disruptive this market can be. While legions of highly paid product managers at Microsoft, Google or OpenAI desperately try to figure out what to even do with raw LLM capabilities, real disruption is happening at the margins. A single developer cobbles together an innovative proof of concept, more or less as a weekend project – and suddenly turns everything upside down.
OpenClaw demonstrated impressively how a simple idea can overturn, overnight, the way AI can operate as an agent and interact with systems. The tech giants may be juggling billions, but they are often simply too uncreative or too blinkered by their own routines to come up with genuinely new interaction concepts. We will very likely see a few more of these surprises in the coming years. The next OpenClaw may already be sitting in some GitHub repository, waiting to make the AI workflows we painstakingly learned today completely obsolete by tomorrow.
Once the industry is finally ready to leave the PoC phase and integrate AI as a “production ready” feature into our operating systems, many of today's AI wrapper tools will simply be washed away. The AI of the future will understand our context automatically – no magic prompt incantations required.
And everything we're currently picking up the hard way as guinea pigs, we can then happily throw overboard. I speak from experience: I went to the trouble very early on of evaluating these tools and learning their quirks, only to discover six months later that, after silent updates, they suddenly worked completely differently. Not to mention the creeping “enshittification” of many products (which has sadly become a very typical “Social IT” career path).
Conclusion: Out of the lab, back to the foundation
So what do we do in the meantime?
First of all: switch off the constant FOMO (fear of missing out). We are not missing a revolution if we don't subscribe to every beta gimmick.
Instead of wearing ourselves out as unpaid testers in the Silicon Valley circus and cramming half-finished PoCs into our “business IT”, we should watch all the hype noise with a little more composure.
If we want to integrate AI sensibly and for the long term, we need to focus on the three real, fundamental innovations these tools actually bring:
- Taming the chaos: We finally have a tool to extract and structure reliable information from gigantic amounts of unstructured data. We can turn text into usable data.
- Scaling output (content generation): LLMs are enormous synthesis machines. The ability to generate new texts, images, concepts, summaries or code snippets from specifications and data within seconds drastically cuts the cost and effort of creating content.
- Natural language as the interface: We no longer have to learn complex software menus or programming syntax. The machine understands our language. That makes technology radically more accessible and easier to use – the machine finally adapts to humans, rather than the other way round.
But to really put these three superpowers to work in day-to-day business, we need to do our homework now: take a look at how you actually work and think about how these innovations could help you do it better. Even the smartest natural-language interface is useless when it meets dysfunctional workflows. And bad content stays bad content, no matter how much lipstick you put on it. If you “optimise” a bad, inefficient process with AI, all you end up with is a bad, inefficient process – it just runs faster. So instead of testing 20 tools: pick 2–3 workflows, raise data quality, define governance, build an integration strategy (RAG/agents/workflow automation) that you can then take into production iteratively. In other words: build your own POCs instead of letting the tech industry's push you around.
Check your process and digital foundation. Then you'll be truly ready when, in a few years, AI has left its embarrassing “Social IT” puberty behind and arrives on the market as a serious, mature tool.
-> Of course, you can also leave the test lab to others: just subscribe to and/or recommend this blog. Anyone who reads here regularly will have noticed anyway that this post is nothing more than a summary of many of the approaches to dealing with AI I've published so far. 😉
