When Software Stops Asking Permission

There are times when Thursday mornings are more frustrating than they should be.

My normal routine is simple. I get in an early workout, have a leisurely breakfast, and then sit down to finish whatever writing I left partially completed the day before.

But on some Thursday mornings, instead of seeing my desktop, I’m greeted by a login screen.

Sometime during the night, my computer decided it was time for an update.

I didn’t schedule it. I wasn’t asked if the timing was convenient. I simply discovered that while I was sleeping, my computer had changed.

Most of the things I was working on can eventually be recovered. Documents are usually easy to find again. Browser tabs can often be restored. But it’s still a nuisance to spend the first half hour reconstructing yesterday’s work instead of continuing it.

Some things aren’t so lucky.

Unsaved notes disappear. Draft articles without automatic save may be lost. More than once I’ve lost part of an interesting conversation with ChatGPT because the browser session didn’t survive the restart.

It’s hardly a disaster, but it certainly isn’t the way I wanted to begin the day.

To be fair, I’m not opposed to software updates. Security patches are essential. Bugs need fixing. New capabilities are often genuinely useful. Given the cyber threats we face today, I certainly don’t want to run outdated software.

What interests me is something much broader than Microsoft’s update schedule.

At some point over the last twenty years, software stopped waiting for us to decide when it should change.

Earlier in my career, I was involved in implementing large software systems. We assumed change was disruptive. New versions were tested. Pilot users tried them first. Feedback was collected. Documentation was updated. Training was prepared. If serious problems appeared, we always had a rollback plan.

The goal wasn’t simply to release new software. The goal was to help people successfully adapt to change.

Consumer software has evolved in a very different direction.

Windows updates itself. Phones update themselves. Browsers quietly introduce new features. Office software changes menus. Image editing programs add AI tools. Our cars receive software updates. Cable providers improve services in the background. Smart devices quietly become “smarter.”

Most of the time these changes make our technology better. But something else has changed at the same time.

The decision about when those changes happen is no longer ours.

That may seem like a small point, but I think it reflects a much larger shift.

We used to own software much the same way we owned appliances. We installed it, learned how it worked, and expected it to remain stable until we chose to replace it.

Today we subscribe to services.

The software is no longer something we install and forget. It’s continuously improved, continuously patched, and continuously enhanced.

From the vendor’s perspective, that’s entirely logical. New security threats appear every day. Bugs can be corrected immediately. New features can be delivered without waiting years for the next major release.

Those are real advantages.

The tradeoff is that stability has become temporary.

Businesses still recognize that change has a cost, but they don’t manage every type of software the same way. Commodity applications such as Microsoft Office, Adobe products, Zoom, and similar tools generally follow a continuous improvement model. Updates are frequent because the work is relatively routine and the risks of disruption are usually manageable.

Mission-critical business systems are different. Customer relationship management (CRM), manufacturing, financial, logistics, and other core operational systems often receive much more structured change management. New releases are tested, phased in, and carefully monitored because even a seemingly minor change can ripple through the business, interrupt operations, or affect customers. The larger the consequences of failure, the more carefully change is managed.

Consumers rarely receive that level of consideration. We simply wake up to discover our software has changed, and we adapt. Most of the time that’s a minor inconvenience. Occasionally it’s much more disruptive.

What strikes me is not that software keeps improving. I hope it does.

What strikes me is how quietly we’ve accepted the idea that our technology no longer waits for us.

Recently I wrote about tools that are beginning to anticipate what we need before we ask. Navigation systems suggest better routes. Watches monitor our health. AI systems summarize meetings and draft emails before we request them.

This week I realized there’s another side to that story.

Our technology isn’t just becoming more helpful.

It’s becoming more independent.

The biggest change isn’t that our software keeps getting better.

The biggest change is that it no longer asks our permission before it changes itself.

Perhaps that’s simply the price we pay for living in a world of continuous improvement. Most of the time it’s a trade I’ll gladly accept because today’s software is more capable, more secure, and more reliable than ever before.

But every now and then, when I sit down on a Thursday morning and discover that my computer has already made decisions on my behalf, I’m reminded that the biggest change isn’t the software itself. The biggest change is that we’ve quietly accepted a world where our technology decides when it is time to change—and we simply adjust.