We’ve reached an uncanny milestone in tech. We are building intimate conversational bonds with AI chatbots, yet the software infrastructure surrounding our daily lives remains as rigid, silent, and fragile as ever.

LLMs tease us with their facilities to write code, but forcing this new form of intelligence to work with programming paradigms that pre-date the World Wide Web is driving a silent crisis of structural decay in large-scale software systems.

This post introduces the Software 4.0 era. Informed by biological processes, it turns software into a living, self-verifying organism that provides the perfect complement to LLMs. It transforms how we build and co-evolve the digital fabric of our world.

---

The state of the art in AI-assisted software development is both phenomenally exciting and deeply frustrating. Some would say alarming, or as one Chief Security Architect put it recently:

What we’re going through today with AI is bananas.

Software development could well be the largest commercial workload for frontier AI labs. While the companies don't disclose detailed revenue breakdowns, an April 2026 analysis found that 34% of LLM usage was devoted to software coding tasks — more than any other category.

The demand is clearly there. Nevertheless, perhaps the simplest description of where we find ourselves might just be: so near and yet so far.

I have just co-authored a paper on the topic with my friend and colleague Dirk Scheffler. We describe a superior way to bring human and artificial intelligences together when it comes to developing, maintaining, and revising the software in our world. As every single one of us is impacted by both AI and all that software, and as the paper itself requires a reasonably high degree of specialist knowledge, I'm writing this post to talk about it in a way that's far more accessible to a far greater number of people.

My goal is to help you understand the gist of things. Ideally, you'll come away with sufficient grasp to share the core ideas with others, whether on a conference panel, in a team meeting, or over dinner — if this is your idea of scintillating conversation.

I'm going to answer the following questions just as briefly as I can while still ensuring this post makes sense.

• What is meant by artificial intelligence (AI)?
• What are large language models (LLMs)?
• What is software development?
• How has software development changed in recent years?
• What's the problem?
• What is Software 4.0?

I finish by describing our technology — a work in progress — and how this shifts things for everyone.

---

What is meant by artificial intelligence (AI)?

To understand why the future of software is changing, we first have to distinguish between two completely different types of artificial intelligence.

• Think of Symbolic AI as the pedantic engineer. This type of AI represents knowledge explicitly using structured rules, concepts, and logic. Instead of just running conventional code like your phone runs its apps, a Symbolic AI can actually reason through complex problems, deduce new facts from clues, and explain its chain of logic step-by-step. Being reliant upon rigid, pre-defined rules, it has the advantage of being fully deterministic, transparent, and auditable, but is less suited to the fluid, pattern-rich ambiguity of natural language and perception.
• Think of Neural AI as the creative artist. This is modern machine learning, and it's what the popular press actually means right now when talking simply about "AI". It doesn't use pre-written logical rules or concepts but excels at statistical pattern recognition. It learns by looking at millions of examples until it gets a fluid 'feel' for things. It is accomplished at recognising a human face, translating languages, creating many kinds of images, and of course AI chatbots, but it deals entirely in probabilities and mathematical guesses, not absolute certainties or logical truths.

What are large language models (LLMs)?

Large Language Models (such as ChatGPT, Claude, Gemini, and DeepSeek) belong entirely to the Neural AI family. As they can write fluent essays, pass medical exams, and argue points of philosophy, we humans naturally assume they possess immense intellect. But the most important thing to understand is that LLMs don’t actually know anything at all.

LLMs do not possess a mental model of reality, nor do they understand facts, logic, or truth. At their core, LLMs are incredibly advanced, multi-billion-dollar versions of the autocomplete feature on your smartphone. Based on the patterns they observe in trillions of sentences written by us humans, they simply calculate a mathematical guess as to which word should come next.

You can think of LLMs as massive curators, compressors, and pattern finders operating over much of humanity's digitally recorded knowledge and expression.

They map words to other words, not words to reality.

What is software development?

Conventional software is the absolute opposite of an LLM's guessing game. Software belongs to the land of determinism — which is a very good part of the reason we became very fond of software in the first place and why it's now to be found everywhere.

Determinism means that a system's actions are entirely fixed and predictable. If a human clicks a button in an app, the computer must execute the exact corresponding piece of software code and update the user interface accordingly every single time, without exception. There's zero room for the software to come back with something like, "I'm 90% sure this is how you log in today."

This demand for certainty makes the human process of software development incredibly intense. Typing the actual code is only a small fraction of the job. Most of the software engineering effort is spent building a detailed mental model of the system's purposes and contexts and getting that down in some form on which everyone can agree, and then designing the shape of the software, and then, yes, writing lines of code. Engineers have to map out how data flows through an invisible web, anticipating for example how a tiny change on line 5,233 of one piece of the software might accidentally cause a catastrophic crash in another piece. It requires total structural discipline.

How has software development changed in recent years?

Now that we're looking back, we can refer to the first era of software as Software 1.0. There was a brief flirtation with the idea that neural forms of AI might simply replace conventional software. Dubbed Software 2.0, it transformed specific domains but never replaced the broad landscape of software development.

Over the last few years, we have instead handed over more and more of the task of writing software code to LLMs, a development attracting the moniker of Software 3.0. We describe it as having moved through three eras:

• Software 3.0 — The Suggestion Box: An LLM acts like a simple assistant. You ask it for a block of code and it types it out for you. It feels magical at first, but because the AI is just guessing words, it frequently hallucinates fake computer commands or leaves typos in the text. It's left to software engineers to look through the code manually to find the bugs and fix them. The phrase vibe coding was coined at this time, coming to imply a blind faith in the output.

• Software 3.1 — The Automated Tester: It was soon realised that LLMs need feedback to be useful. In this era, engineers connected the language models directly to code-testing tools. Now, when the model generates code, the testing tools leap into action. If the program fails any of the tests, the tools pass the error messages back to the model so it can have another go. This is a massive upgrade because the LLM can clean up its own basic errors before a human might ever see them.

• Software 3.2 — The AI Committee: This is the current state of the art. As software projects are too big for one LLM, we now wrap the language model inside a massive engineering framework. First, we essentially stuff the LLM's short-term memory with a textbook of custom background information before it writes a single word — a process known as context engineering. Second, we build a detailed automated pipeline where teams of different AIs pass code back and forth, reviewing, testing, and boxing each other in until the system forces a finished product. This arrangement is known as a programmable harness.

What's the problem?

If you read many of today's popular headlines, it sounds as if AI coding is completely solved. Many frontier labs offer their own coding tools. Relatively new companies such as Replit and Lovable enable anyone to build beautiful, functioning web apps in a matter of minutes just by describing what they want in plain English. It looks at least as if it's working flawlessly, and indeed the underlying problems might not matter greatly for a throw-away prototype or personal website.

But when anyone tries to build massive, heavy-duty enterprise systems, things break catastrophically. Here are three root causes:

• No World Model or Grounding: Because the AI committee is just passing text blocks back and forth, it doesn't actually 'see' or understand the digital architecture it's creating. It can't assess its suitability for the world in which it will operate because it doesn't understand that world. It has no anchor (or grounding) in the living reality of the running program.

• Insufficient Breadth and Depth: Complex software can enter millions of unpredictable states. A neural AI simply cannot anticipate or handle the breadth and depth of the system, no matter how much paraphernalia we surround it with. In the lexicon, we say it lacks the requisite variety.

• The Wrong Tool: Fundamentally, today's programming languages — e.g. Python, Java, Rust — were designed by humans, for humans. They were meant for human eyes to read and human fingers to type and, importantly, relied on human brains to maintain some of the contextual understanding. Forcing a fluid, probabilistic neural AI to do its thing by typing out thousands of lines of rigid text files is a fundamental mismatch. It's like inviting a brilliant artist to build a highly complicated Swiss watch using a paintbrush.

What happens when an AI committee builds a large software system this way? As the combination of LLM and harness gubbins is so good at writing text that looks convincing and is, importantly, designed to pass the tests, it doesn't trigger the alarms. Nevertheless, it's stacking statistical guesses on top of statistical guesses, and the software is developing deep, silent structural decay.

Given the size of these systems, the decay can take months and perhaps years to become apparent. Eventually, an engineer takes a look under the hood, takes a deep breath, and asks for a strong cup of coffee. The system has become a fragile, indecipherable jumble that's primed to collapse under its own weight. If the engineering team puts off the inevitable, users will soon be on the receiving end, which is never good for business.

Ultimately, we consider this to be a software problem, not an LLM problem. We are going about software in a way that's incompatible with the phenomenal talents of large language models.

What is Software 4.0?

We have to stop forcing LLMs to adopt a plainly unsuitable paradigm. We need a new paradigm, and with astonishing creative ingenuity we decided to call this era Software 4.0.

When looking for a way to maintain order within a messy, changing environment, we look at the work of what you might call the ultimate engineer — Mother Nature. Living organisms don't 'do code' the way conventional software development does, yet they manage to survive and maintain their structure brilliantly.

Here are four core biological principles that influence our work deeply:

• Self-production: Living cells continuously produce both their own internal components and the membrane boundary that separates them from the outside world. These processes prevent cells, organs, and organisms from dissolving into chaos. Biologists refer to this self-production as autopoiesis.
• Anticipation: More complex living systems — including us — constantly build internal expectations about their environment so they can adapt appropriately to both opportunities and threats.
• Resilience: Your body automatically shifts its internal systems — such as your heart rate or body temperature — to absorb external shocks and stay alive.
• Protective Memory: Your immune system retains a record of past infections, allowing it to mount a faster, stronger response the next time without starting from scratch.

These four biological dynamics exhibit a completely different architecture from the flat, dead text files of conventional software. To make a software system truly self-reflective, self-regulating, self-producing — to make it life-like like this — it must be envisaged as a strange loop.

Coined by the cognitive and computer scientist Douglas Hofstadter, a strange loop occurs when you move through the layers of a hierarchical system and find that the top level and the bottom level are engaged in a cycle of mutual creation. Think of M.C. Escher’s famous drawing of two hands, where each hand is actively drawing the other into existence. In fact, the idea of 'up' and 'down' implicit to the idea of a hierarchy starts to look a bit silly; the more accurate terminology is heterarchy.

Far from being an abstract novelty, this looping serves a profound engineering purpose. Here's an example snapshot of this never-ending looping in our Software 4.0 contexts:

• The humans' high-level goals shape this new form of software,
• And these intents and the software’s native rules prompt, shape, and constrain the LLM’s next contribution directly,
• And that contribution prompts the human to restate an intent in dialogue with the LLM,
• Which then collaborates with this new form of software to instantiate a corresponding change,
• ... and so on and so forth.

As the channels of communication continuously cross and cross-check one another, the system doesn't just run static code — it is an unbroken circuit constantly observing, validating, and reshaping its own internal reality in real time. It allows a fluid, unpredictable neural AI to safely rewrite and help co-evolve a heavy-duty enterprise system in real time, without the risk of structural collapse.

In our manifestation of Software 4.0, this new form of software is called supersoftware. Think of supersoftware as software that is itself symbolic AI. LLMs and supersoftware play to each other's strengths and make up for each other's weaknesses — the ideal collaboration, naturally.

In the lexicon, the combination of supersoftware and LLM is said to form constitutively coupled neurosymbolic AI.

Era	Paradigm	Mode	Source of intelligence
1.0	traditional software	instructions	source code
2.0	neural AI	parameters	model weights
3.0	the suggestion box	prompts	weights + short-term memory
3.1	the automated tester	agent feedback loops	weights + external testing tools
3.2	the AI committee	optimised pipelines	weights + structured engineering harness
4.0	supersoftware	strange loop	life-like system

Recognitive — the programming language designed for LLMs

Traditional software, however beautifully written, is essentially a silent instruction manual — it simply tells a machine what to do. It cannot explain itself to anyone or anything else reading it from the outside. Data, configuration settings, error messages, business rules, and interface definitions are all packaged and transmitted in a cacophony of bespoke and incompatible formats.

Nature solved problems such as these aeons ago. Therefore, the design and development of a programming language we call Recognitive is directly informed by nature's mastery — it's the language in which supersoftware is expressed.

Recognitive is different in kind. Every component of a supersoftware system continuously declares what it is, what it can do, what it expects, and what it guarantees — not as a separate document that might be out of date by Tuesday, but as a living property of the structure itself.

Following nature's lead, Recognitive uses a single unified structural format through which everything travels. Data, logic, errors, configuration, and behaviour, all speak the same structural tongue. The Recognitive language provides the equivalent to nature's universal genetic code, while the specific application authored within it acts as the DNA blueprint. To translate this blueprint into action, the platform uses a universal communication standard that acts like a cell's ribosome — the molecular engine that reads the genetic code and projects its reality into the living cell. These encoded instructions are finally enacted as a living, functioning digital organism — supersoftware.

For an LLM, this environment is heaven-sent. Rather than navigating a fragmented Tower of Babel, it engages with a system that expresses its entire living reality in one coherent, readable form. The supersoftware has a sense of itself, represents itself, and can govern and modify itself. The LLM doesn't have to fall back on committee conversation to guess at blind architecture.

The entire dynamic changes. Much like the human brain delegates autonomic reflexes and motor coordination to the cerebellum, the LLM is freed from managing low-level execution. Importantly, it's not off-loaded to something extraneous to the software, but to the software itself.

The LLM simply expresses its creative, probabilistic intentions — acting as the system's cortex — and supersoftware translates that intent into a deterministic, structural shape in real time. And in actual fact, the LLM only expresses sub-intents because the ultimate intelligence in the mix — and the one setting the top-level intents — remains strictly human, driven by the wisdom, strategic vision, and lived experiences of domain experts and software engineers.

The supersoftware layer acts like the cellular membrane for that specific application. If the LLM makes a creative leap that threatens the system, this structural boundary makes that action impossible to execute. This turns verification from a test you run after the fact into a live built-in safeguard.

And if that wasn't enough, the way in which supersoftware presents itself is far easier for LLMs to grapple with than software written in traditional programming languages. As the LLM doesn't have to waste immense computational energy trying to decipher hidden connections or translate messy, fragmented code and structures, the entire relationship becomes drastically faster, cleaner, and cheaper.

How things shift for everyone

The impact of this technology will ripple far and wide. It will fundamentally rewrite the rules of how we work, how we think about companies and other forms of organising, and how we interact with and through the digital fabric of our world. Importantly, given its natural heritage, we're intent on it feeling more natural than computer systems have ever felt. You will, I hope, have noticed that we're engaged in a process of human-centred rather than AI-centred design.

We’ve dreamed for decades of a world in which software engineers are true strategic partners with the rest of the organisation, rather than isolated mechanics tasked with installing and fixing the plumbing. Supersoftware finally manifests this reality in the LLM age. When code is no longer a dead, flat text document, it becomes a digital organism in relationship with us. Engineers move from being literal translators of syntax to high-level architects of intent, working side-by-side with every stakeholder to co-shape the digital reality of the organisation.

When I say it touches the very essence of organising, I mean it gets to the heart of how any complex system holds together — right up to the fabric of our social life, our families, and our communities. And this brings us to something that deserves to be said plainly.

There is well-founded anxiety sweeping through society today about the centralising consequences of massive LLM service providers. Nobody wants a few tech giants holding the keys to intelligence, so to speak. The more dependent we become on vast, opaque neural systems we cannot inspect, verify, or govern, the more we cede our autonomy and agency.

Software 4.0 offers a fierce, necessary route forward. Supersoftware remains as decentralised as software has always been, but it is now radically accessible to everyone concerned. It encodes human intent and boundaries. It forms a naturally beautiful collaboration with LLMs, and ultimately keeps those LLMs in check in precisely the way we need.

We’ve been conditioned to think of human-machine collaboration as something cold and mechanical. Today, we are in an intermediate stage — forming conversational relationships with chatbots that feel human, even while the traditional software environments around us remain rigid and fragmented.

I believe Software 4.0 changes that narrative completely. It takes us past this conversational veneer to give us technology where the underlying architecture itself mirrors the resilience of life, entirely shaped by human intent.

In this light, we may well begin to see ourselves differently — not as passive users of fragile, alien machinery, but as something more integrated and more intentional. Each of us combines with our chosen technologies in ways that suit ourselves, our families, and our communities.

By leaving behind the brittle software structures of the past, we aren't just adapting to the intelligence age — we are building the tools to thrive in it.