Recently, I noticed an interesting phenomenon at work.

Some users with strong business expertise have started using WorkBuddy to retrieve data from internal information systems and BI platforms. They then analyze and organize that data around their own needs, sometimes accomplishing things that once would have required a dedicated software feature.

On the surface, this is simply AI helping users find and analyze data.

But the more I thought about it, the more I felt that it might point to a much larger change:

Software itself is changing shape.

In the past, we built software first and then asked users to work in the way the software had been designed.

In the future, that sequence may increasingly be reversed:

A user first tells an Agent what they want to accomplish. The Agent then uses available data, permissions, and capabilities to assemble a way of working for that particular task.

This means that part of what we have traditionally called “building features” may gradually become:

Generating workflows on demand.

Software Has Always Defined in Advance How Users Should Work

The software we use is full of menus, pages, buttons, forms, reports, and processes.

But if we look past those visible elements, many software features are essentially doing the same thing:

Defining in advance how a user should complete a task.

The business raises a requirement.

A product manager interprets it.

Developers turn it into a feature.

Users then follow the path that feature provides.

Traditional software is therefore a continuous process of hardening business needs into fixed structures.

When the business needs a new way of working, we add a feature.

When it needs a new report, we build one.

When it needs a new process, we design and implement it.

Over time, the software accumulates more menus, pages, and features.

That made sense in the past.

Users could not directly work with complex data and systems on their own.

Software developers had to package those capabilities in advance.

Agents are beginning to change that.

Agents Are Changing More Than How We Use Software

When people discuss AI today, they often imagine things like:

Let AI retrieve data for me.

Let AI fill out a form for me.

Let AI summarize information for me.

Let AI operate existing software for me.

All of these are valuable.

But I think something more important is happening:

Agents are making it possible to generate some workflows at the moment they are needed, rather than develop them in advance.

Suppose a business user suddenly wants to know:

Which products have shown unusual performance recently, and what might be causing it?

In the past, if the system did not already have the right report, the user could usually do little more than submit a request.

They would then wait for a data analyst, product manager, or developer to handle it.

Now, as long as an Agent can access the relevant data within the user’s permissions and understand the relationships within it, the Agent can help perform the analysis directly.

If the user asks a different question tomorrow, a new feature may not need to be developed.

The Agent can recombine existing data and capabilities.

The change is no longer simply:

AI makes existing software easier to use.

It is:

Software no longer needs to enumerate every possible user need in advance.

Software May Shift Its Focus from Features to Foundational Capabilities

In the past, we often evaluated software by the number of features it had.

More features meant that the software covered more scenarios in advance.

But if many workflows can be composed dynamically by Agents, the number of predefined features may no longer matter as much as it once did.

What may matter more is:

Whether the data is reliable.

Whether the business rules are clear.

What capabilities the system exposes.

What permissions the user has.

Which actions can be executed directly.

Which actions require approval.

In other words, the things software needs to build and maintain over the long term may gradually shift away from individual features and toward a deeper foundation:

Reliable data, clear business semantics, stable business capabilities, and explicit permissions and governance.

The pages, reports, analytical views, and some workflows at the top can then become increasingly flexible.

Future Software May Have a Stable Foundation and Dynamic Ways of Working

I think this is one of the most important changes in the Agent era.

In the past, we invested enormous effort in keeping pages, menus, and processes stable.

In the future, the things that truly need long-term stability may be:

  • which data is authoritative;
  • what that data means;
  • what the business rules are;
  • what each user is allowed to do;
  • which actions require approval;
  • whether every important action can be traced.

These things cannot change arbitrarily.

But on top of that foundation:

How users view data.

How they organize information.

How they perform analysis.

How they compose their own ways of working.

All of these can become more dynamic.

Put simply:

The lower layer becomes more stable, while the upper layer becomes more flexible.

This Does Not Mean Traditional Software Will Disappear

Of course, not all software will become something generated on the fly.

The more important and risky an operation is, the more it requires determinism.

Core business operations such as payments, approvals, financial processing, production instructions, and quality release will still require explicit rules, strict permissions, and complete audit trails.

These are not places where an Agent should be free to improvise.

But other kinds of work—

Queries.

Reports.

Data organization.

Information synthesis.

Ad hoc analysis.

Decision support.

Personal workflows.

Internal tools.

—are likely to change first.

One major reason these tasks had to be developed as separate features in the past was simply that:

Users could not directly organize data and system capabilities for themselves.

Agents are beginning to occupy that middle layer.

“Software” May No Longer Mean a Fixed Interface

Following this idea leads to an interesting question:

Must the systems we call CRM, PDM, BI, and procurement software always remain separate applications with fixed sets of features?

Perhaps not.

The future may instead have a stable business foundation.

It would contain data, rules, permissions, and reusable business capabilities.

Different people would then see different things according to their responsibilities and current tasks.

Salespeople might see a sales workspace.

Engineers might see products and drawings.

Managers might see business analysis.

But these experiences may not need to be developed in advance as several completely fixed applications.

They could instead be:

Different projections of the same business world for different roles and tasks.

From this perspective, I like this line:

Application is becoming a projection, not the system itself.

The software interface may no longer be the system itself.

It may instead be a projection of the underlying data, business rules, and capabilities for a particular need.

What Becomes More Important Is the Business Itself

This has also made me reconsider a question:

What is actually valuable in software in the Agent era?

In the past, it was easy to assume:

A system is valuable because it has many features.

But as Agents become more capable, the cost of developing many generic features will fall.

A page.

A report.

A simple data query.

An internal tool.

All of these will become easier to generate.

What remains difficult to replicate is:

How the business actually works.

How different entities relate to one another.

Which rules must never be violated.

Which data can be trusted.

What each state means.

Which actions are allowed under which conditions.

An Agent cannot invent these things from nothing.

They come from the business understanding accumulated by a company or an industry over many years.

So I increasingly believe:

As software implementation becomes cheaper, business understanding becomes more expensive.

What companies need to accumulate in the future may not be only code and features.

It may be:

An understanding of their own business world.

We May Need to Rethink What It Means to Develop Software

When building software in the past, our first question was often:

What features should this system have?

In the future, that question may gradually become:

What reliable data, business rules, capabilities, and permissions must we provide to Agents so that users can safely accomplish their work?

These are two fundamentally different approaches to software design.

In the past, we tried to:

Develop in advance all the features users might need in the future.

In the future, we may focus more on:

Building a stable enough foundation from which new ways of working can continuously emerge.

We would no longer try to predict every future user need.

Instead, we would invest in the things that truly need long-term maintenance:

Data.

Business rules.

Capabilities.

Permissions.

Governance.

Then we would return some of the choice over how these things are used to the user.

The user would no longer be limited to asking:

Does this software have this feature?

They could simply say:

This is how I want to work right now.

The Agent could then use the available data, capabilities, and permissions to assemble that way of working.

I think this is where Agents truly begin to change software.

It is not simply about adding a chat window to an existing application.

Nor is it only about helping users click fewer buttons.

The deeper change is:

The shape of software, once defined in advance by developers, is becoming increasingly dynamic.

Software will not disappear.

But our understanding of what software should be may be changing.