Software that adapts to you, not the other way around

Imagine you buy a new pair of headphones. Good ones, the kind that sound great and feel great on your ears. But they come with an app.

The app has a ten-band equalizer you’ll probably never touch. It has a “soundscape” mode to simulate being in a coffee shop. It has firmware update notifications. What it doesn’t have is the one thing you need: the ability to map the physical buttons to the actions you actually use, and —this one’s more niche— to route different audio sources to each ear so you can listen to two things at once.

That function doesn’t exist. Neither does the possibility of creating it. The app is sealed.

Software always wins the fight

That scenario captures something we take for granted: you adapt to the software, never the other way around. You learn to use it as it was designed, you reorganize your workflow to fit its screens, and you accept that 60% of the features are useless to you — while the 5% you really need exists in no menu.

It’s not developer carelessness. It’s a structural problem: a centralized team can’t meet the needs of millions of different people. The doctor who wants to remove useless fields from their records system. The accountant who needs a specific calculation no spreadsheet includes. You, with your headphones and your use case nobody else has, but that matters to you.

Software is designed for the average user. And the average user doesn’t exist.

The idea that could never take off

There’s a name for the opposite vision: malleable software. The idea that people should be able to shape their tools to their own needs — without being programmers, without waiting for a company to decide to implement your request in the next version.

It’s not a new idea. Researchers have been working on it for decades. The problem was always the same: to shape software, you needed to know how to program. And that limited the market to exactly the people who could already build whatever they wanted from scratch. Malleable software for programmers turned out to be, basically, redundant.

VS Code is a notable example of where this worked at scale. Microsoft’s editor started out minimalist; the community built everything else on top: themes, integrations with any imaginable service, AI tools, support for every existing language. Today it has more than 60,000 extensions and 73% of the world’s developers use it. When you give people the means to shape their software, they shape it — and the product becomes more valuable for everyone.

But note: those users are developers. People who know how to create the tools they need. The experiment worked perfectly in the one segment where it was never really necessary.

LLMs changed the equation

Here’s the twist: LLMs just removed the only obstacle that mattered.

Translating informal intent — “I want this to do X when Y happens” — into executable code was always the bottleneck. It was a language problem: you think in needs, software speaks in functions and methods. Nobody had been able to close that gap for the ordinary user.

LLMs closed it. And the mechanism is simpler than it seems.

A company that wants to make its product malleable doesn’t need to reinvent its architecture. It only needs to prepare a pre-prompt: a text with the context of how the product works, what can be customized, and the instructions needed to build something on top. The user copies that pre-prompt, adds in natural language what they want to do —“I want a view that only shows me the euro exchange rate and warns me if it drops below a certain value”— and sends it to any LLM chat. ChatGPT, Claude, Gemini, whatever you have on hand.

That’s it. No configurations. No learning APIs. No installing anything special. The barrier between “I want this” and “this exists” shrinks to writing a sentence.

What it would look like in practice

Let’s think about Quantis, vzla.io’s currency calculator. Today it has several tools for different use cases: conversion between currencies, cross rates, calculators for specific scenarios. Useful. But not every user needs every tool, and there are needs that still aren’t covered.

Imagine Quantis were a canvas. A base screen with real-time rate data, and nothing more. From there, each user builds their own view: the calculator they use every day, the historical chart for the period that interests them, the alert for when the exchange rate hits a certain threshold. Not because Quantis programmed that specific function — but because the user described what they needed, pasted the Quantis pre-prompt into their LLM chat, and built it themselves in minutes.

That Quantis wouldn’t be the same product for everyone. It would be the product each person needs.

The door is open

Is this going to happen? We don’t know for certain. The market decides, and there are economic, technical, and cultural forces that can accelerate or slow any trend. Malleable software has had brilliant advocates for decades and still isn’t the norm.

But something changed this time. The obstacle that always blocked the door is gone. And that, for anyone who builds products, who imagines how things could be, who was ever frustrated by an app that wouldn’t let them do what they needed…

The idea that software adapts to you, and not the other way around, has stopped being just a pretty idea.