By Farooq Adam, Founder, Fynd
For decades we have been reshaping our organisations to fit the software we bought. The cost of building was too high to do it any other way. That cost has now collapsed. The question is no longer how do we adapt to the tool. The question is why does the tool not adapt to us.
The long wave of digitisation
There has been a long wave of digitisation running through every industry for the last few decades. Every few years the underlying technology shifts. Mainframes gave way to client-server. Client-server gave way to the web. The web gave way to mobile. Each shift forced companies to rebuild or replace the platforms they used to run their businesses. And each time, the cost of building was enormous.
Because the cost was so high, software companies built for the lowest common denominator. They identified the most generic version of a workflow, packaged it into a product, and sold it to as many companies as possible. No two companies operate the same way, but every company was asked to use the same software. The result was predictable. Every enterprise ended up buying a collection of tools that almost did what they needed, then spent years and millions taping them together with custom integrations, workarounds, and manual processes. The software did not fit the business. The business was reshaped to fit the software. This was accepted as normal because there was no alternative.
AI has changed this economics completely. The cost of writing software has fallen to near zero. If you know what you need and you have access to the underlying systems of record, you can build it.
Quickly. Precisely. Shaped to the way your organisation actually works. This changes everything about how enterprise software is made, sold, and used.
We are calling it the rise of Malleable Software.
Malleable enterprise software
The first and most immediate shift is inside the enterprise. When the cost of building collapses, you are no longer locked into a vendor’s user interface. You are no longer locked into their assumptions about how your business should run. You are no longer forced to choose between an off-the-shelf product that does not quite fit and a custom build that takes two years and costs a fortune. A third option has arrived: software that shapes itself to the business, continuously, in real time.
The key is separating what is stable from what should be fluid. In any enterprise, the data models are stable. Customers, orders, inventory, transactions. These structures do not change daily. But everything above the data layer should be fluid. The workflows, the interfaces, the decision logic, the reports. These need to conform to how the company actually operates, not how a software vendor imagined it might operate. When AI can generate application layers on demand from well-defined specifications, the entire layer above the data becomes malleable. It moulds to the organisation rather than forcing the organisation to mould to it.
In a malleable enterprise, the software does not just adapt once during implementation. It adapts every day. The business changes a process, the software reshapes to match. A new product line is added, the system reconfigures without a development cycle. A regulation changes, the compliance workflow rebuilds itself overnight. The human input required to operate these systems decreases progressively. Think of it as a ladder of autonomy. At the first level, the software assists: it surfaces the right data at the right time and waits for a human decision. At the next level, it recommends: it proposes the decision and waits for approval. Further up, it acts autonomously on routine decisions and only escalates exceptions. At the highest levels, the software runs entire functions, from procurement to logistics to customer service, with human oversight reduced to strategic direction. The system auto-corrects. It learns from every transaction. It reshapes itself as the business evolves, day by day.
Malleable consumer apps
The same problem exists on the consumer side, and we have been ignoring it. Every application we use daily was built for the largest possible audience. YouTube has hundreds of features. Any individual uses two or three. Hundreds of engineers sit inside YouTube trying to figure out the next feature that will be useful to someone. But when you build for everyone, you build for no one. The interface is cluttered with things you will never touch. The things you actually need are buried three taps deep. The application does not know you. It knows a statistical average of millions of users, and it serves that average to your screen.
Now the cost of building has collapsed on the consumer side too. There is no reason every person should see the same application. There is no reason the interface should be static. There is no reason you should have to navigate a product designed for a lowest common denominator that does not represent you. The same malleability that reshapes enterprise software to fit a specific organisation can reshape consumer software to fit a specific person.
The current conversation around this is too narrow. The industry is excited about agentic interfaces, the chat-based model where you ask, the system responds, you ask again, the system responds again. This is a primitive. It is a text-based command line dressed up as a conversation. It requires constant human input. You are still driving. The agent is just a new kind of steering wheel.
The real shift is beyond that. The best interaction with software is no interaction at all. If the software truly understood how you work and what you need, it would act without being asked. You get in your car, your music starts playing. Not because you asked for it. Because the system knows you, knows the time of day, knows your pattern, and has enough context to act on your behalf. You walk into the office, every application you review each morning is already open, already showing you what changed since yesterday, already highlighting what needs your attention. You did not ask for any of it. The software anticipated it.
From reactive to anticipatory
Software has always been reactive. You click, it responds. That is every application ever built. The agentic wave adds a layer: you type a request, it executes. But it is still waiting for you. Anticipatory software does not wait. It has built a model of who you are, what you care about, and what you are likely to need next. It acts before you ask. It surfaces things before you search. It resolves problems before you notice them. It reshapes itself around your intent without requiring you to spell out that intent every single time.
This requires deep context. Not the shallow context of browsing history and click patterns. Deep context means knowing what someone actually wants, what they care about, what they refuse to compromise on. On the enterprise side, that context comes from sitting with domain experts: the factory floor manager, the merchandise buyer, the logistics head. Their knowledge gets encoded into specifications that tell the software what shape to take. On the consumer side, that context comes from living with the person over time. Observing patterns. Noticing preferences. Building a model that is specific to one human, not a statistical composite of millions.
The applications we use today will feel, in ten years, the way paper forms feel today. Clumsy. Generic. Requiring enormous effort for simple tasks. The malleable application of the future will feel
like an extension of your own thinking. Not because it reads your mind, but because it has spent enough time with you to know what you need before you articulate it. You supply the will, the intent, the direction. The software shapes itself to execute it.
A new category
What is emerging is not an upgrade to existing software. It is a new category altogether. SaaS gave everyone the same product at a lower price point. Custom development gave each company a bespoke build at enormous cost. Malleable software sits in between and beyond both. The product is alive. It breathes with the organisation or the person it serves. It never settles into a fixed shape because the world it operates in never settles either. The data models hold steady underneath, providing structural integrity. Everything above the data layer is fluid, reshaping itself as the context evolves.
For enterprises, this means an operating system that adapts to leadership’s way of thinking, compounds intelligence with every transaction, and progressively absorbs operational functions until it runs them with only strategic direction from above. For consumers, it means applications that stop treating you as a member of a segment and start treating you as an individual. What you see, how you navigate, what gets surfaced, when you are interrupted, and when you are left alone. All of it shaped by context that is yours alone.
The era of software that forces humans to change is ending. The era of software that changes itself has begun. The companies that build it will define how the world works for the next several decades. The companies that keep buying off-the-shelf tools and taping them together will wonder why they fell behind. The answer will be simple. The software they used was rigid. The world was not.