On the Future of Software

I am in a philosophical, slightly visionary mood again today, so let’s talk about what software may look like in a not-too-distant agentic future.

We assume that programs are deterministic. They have a set of functions described by developers in advance, and they behave predictably. This is a beautiful concept for an engineering mind, but it has a fatal flaw. Programs have to be thought through, designed, and developed. If we are talking about business, they also have to be broad enough to be useful and to pay for themselves. That is hard, and you cannot satisfy everyone. As a result, either there is no software for your exact task, or it is not worth the money, or your task is solved painfully because your scenarios are special and nobody designed for them.

And yes, you can probably see where I am going. It feels like a future is already taking shape where a user only needs an agent on their computer to get work done. Let’s be honest: a large share of software is just connective tissue that combines known building blocks — frameworks, libraries, and databases — with a pinch of domain-specific logic. In this future, that connective tissue becomes dynamic.

When I say “agent”, I do not mean Claude Code or Pi. Those are embryos of agents. Normies will never come to them. Codex App or Claude Desktop/Cowork are much closer to something normal.

Markdown skills are the new software. A skill can describe what dependencies and runtime it needs to install. Scripts, code, and any resources needed for the skill can live next to it. Skills are becoming larger and larger. The more branching the prompts and all this machinery become, the closer they get to the old idea of software.

The huge and crucial difference is that code no longer decides what the task-solving process looks like. The agent, your prompts, and the skill author’s prompts do. Application code as the user’s entry point may stop existing. It turns into a loop: agent code → neural network → auxiliary application code. And if there is no auxiliary code, the agent will generate it if it decides it needs to. You could say that part of the executable code moves into the inference stage — and inference becomes part of the application runtime in the broader sense.

An ordinary user in some future GUI agent will be able to install applications — skills — from a marketplace. Skills will stop being “just prompts” and will describe, at a high level, which components the agent can use. With that, the agent will be able to compose a convenient GUI for consuming or editing something right inside the same agent, Canvas/Artifacts-style. Not so it looks like vibe coding, but so it looks like a dynamic yet native UI. We are almost there already, except for the agent integration.

Previously, a person connected systems manually or through code. But as it turns out, a huge amount of software collapses into a skill, or into a skill with scripts.