Skip to main content
Rick Blalock

The feature you need now is probably temporary

Software should add what you need and remove it cleanly when you’re done.

Most software treats a useful feature as something to keep around forever. You install an app, turn options on, and over time the product accumulates modes, panels, integrations, and preferences for situations you may never be in again. Features stick around because removing them is awkward, the design assumed permanence, some users might complain, or it could mess up a product manager's metrics.

When AI makes it cheap to build small capabilities on demand, a lot of what we need from software turns out to be temporary. An insurance quote and negotiation dashboard. A research workspace for a single paper. A routine built around one semester.

You still need a core app where your information and history live. Everything specialized around it can come and go, especially now that agents can assemble it on the fly.

That sounds great but we're humans and when things get removed is hard for us.

I care about a future that is not just software features that can be added when I need, but software that can remove a capability when it's not needed. That sounds so simple but I'm telling you it's one of the hardest things to do.

A recent paper on dynamic software composition breaks that problem into two halves.[1] One is cleanly reversing what a component changed when it is removed. The other is updating everything that depended on it as those dependencies appear, change, or disappear. Without both, a system can grow new abilities far more easily than it can safely shed them.

I have written before about a computer that learns how you work and about making a computer your own. This feels like the next question. Adapting to a person cannot just mean piling more onto their machine. Sometimes the most personal thing software can do is notice that a situation has passed, take the temporary capability back apart, and leave the rest of your environment intact.

Now this is on the technical side of it. I'd still say that this paper is only taking on the easy part of the equation. The hard part is still the humans clinging on to things they still think are important and are unwilling to let it go.

Some other things to consider: There is a legit limit to what undo can cover. Reversing state works best inside the computer. Sending an email, charging a card, or posting a message creates consequences for other people, which is different from cleaning up a local panel, shortcut, or workflow. The paper draws that same line between internal changes a system can revert and external actions that instead require withholding or compensation.[1]

For a long time, using software and changing software were separate activities. One was for everybody, and the other belonged to developers, IT, or whoever owned the roadmap.

When features can be temporary, and the users can on-demand ask for a temporary feature to solve a problem, those two start to blur a lot don't they? You ask for what the moment requires, the computer puts it together, and later it takes it back apart.

The feature you needed for a while should be allowed to end.

Sources

[1] Yifan Shi, Wei Zhang, and Tianyi Cui, “A Programming Paradigm for Spatiotemporal Composability”