I never liked the Apple Health app. Or any investment app, for that matter.

The problem with these applications is that every meaningful decision about how I interact with them was made before I ever opened them. What gets shown, how data is grouped, what counts as signal, and what gets ignored are all baked in. I can use the system, but I cannot change it. At best, I am customizing within a framework someone else chose.

There is an economic reason software evolved this way.

Software used to be expensive to build, maintain, and distribute. The only way the economics worked was shipping one product to many users. So companies built a stable interface, fixed the behavior, and shipped the same thing to everyone. If the product failed to quite fit you, you adjusted. Distribution depended entirely on standardization.

AI agents are breaking this rigid, one-to-many model by driving the cost of code generation down drastically. The user absorbed the friction because fixing a minor annoyance required a full engineering cycle. Now, because AI agents have significantly lowered the barrier to writing code, I was able to easily build my own custom health and stock investment trackers. I am finally completely happy with how my software behaves.

As generating functionality becomes cheaper, this compromise vanishes for everyone. The UI and workflows of applications can be dynamically changed based on user habits and preferences. The economic wall that forced everyone into the exact same standardized box simply collapses.

· · ·

It is easy to misjudge where this will lead in the future. One might think all software will collapse into a single LLM chat application connected to a sea of software APIs, where an orchestrating LLM replaces individual applications entirely.

However, this universal chat paradigm overlooks fundamental needs of human-computer interaction. Conversational AI serves as an excellent initial stepping stone, but remains a highly inefficient control mechanism for a polished, finished product. Most interaction with software involves navigation, filtering, editing, comparing, and repeated micro-actions. These require speed, determinism, and spatial consistency. Running them through a text model is too expensive, too slow, and frankly, chat or voice proves inadequate for precise control.

Therefore, individual software applications are not going to disappear. Instead, the most likely outcome is that they will evolve by separating into two distinct parts: the underlying logic engine and the adaptive presentation layer.

The underlying logic engine remains with the company. This includes the business logic, rules, heuristics, optimization layers, and execution infrastructure. The company simply provides what the software can do, the data it generates, the constraints it operates under, and the API to communicate with it.

· · ·

The real change happens in the presentation layer.

The presentation layer no longer has to be a fixed artifact. As AI agents become good at generating code based on specifications, this layer can be generated on the fly based on a high-level adaptable blueprint from the company. This blueprint acts as a foundational guide, prioritizing essential actions and data summaries based on common user behavior.

A local AI agent takes this blueprint and builds the interface around the user's current context: what they are trying to do, what they have done before, and what signals matter to them.

Different context, different interface. This is “contextual software.”

The concept of a pre-compiled, one-size-fits-all monolith will become obsolete. Distribution will shift away from rigid standardization toward contextual instantiation. Instead of a locked application, what you will receive is a system whose final form is constructed around your immediate needs.

Take my health tracker. It no longer shows fifty metrics I never asked for. Just resting heart rate, sleep quality, and running pace. My investment app works the same way. No candlestick charts or options chains. Just a simple portfolio summary.

But contextual software goes further than just adding or removing features. It reshapes itself around what you are doing right now. Open a video editor to trim a clip, and you see a timeline, a cut tool, and an export button. Open it the next day to color grade a short film, and the interface rebuilds itself with scopes, curves, and layer controls. Same software, completely different experience.

Very soon, you will dictate exactly how your favorite software behaves.

Thanks to Manali for reading the early drafts and for her feedback.