AI makes custom software economically accessible — what does that mean for generic software?

1. A familiar situation: installing another plugin

Many software projects start in a very similar way.

A company wants to add a small feature to a website or application.
For example:

a form with additional logic
an integration with an external API
a small internal workflow

The first step is rarely: "let's build this."

Instead, the first question is usually:

"Is there a plugin or tool for this?"

So a plugin is installed.
Sometimes another one.

Before long, a relatively simple website consists of:

a CMS
twenty plugins
several external services
scripts connecting everything together

This often works well — until something needs to change.

At that point it becomes clear that the functionality you actually need is only a small part of all that software.

The rest is overhead.

AI changes something interesting here: it becomes easier to build that small piece of software yourself.

2. Software became generic because custom development was expensive

For decades, software development has increasingly been dominated by generic solutions.

Plugins. SaaS tools. Templates. Low-code platforms.

The reason was simple: custom software was expensive.

If you needed a new system or a specific feature, you usually had two options:

build it yourself (expensive and time-consuming)
use existing software (faster and cheaper)

For most organizations the decision was obvious. They adopted software that did almost what they needed and accepted the compromises.

This model produced an enormous ecosystem of software:

CMS platforms like WordPress
SaaS tools for almost every business function
plugin ecosystems with thousands of extensions
configuration platforms that allow systems to be built without code

But all of these solutions rely on a core assumption:

Writing software is more expensive than adapting existing software.

AI is beginning to change that assumption.

3. Generic software has always had a hidden cost

Generic software solves an important problem: you don't have to build everything yourself.

But it almost always comes with trade-offs.

Anyone who has worked with plugin ecosystems or SaaS tools recognizes this pattern:

software covers 80% of what you need
the remaining 20% requires configuration or workarounds
dependencies accumulate over time

A simple website may consist of:

a CMS
twenty plugins
several external services
scripts connecting everything

This works well — until something needs to change.

At that point the hidden complexity appears:

updates cause conflicts
plugins stop being maintained
systems depend on each other
performance suffers from additional layers

For a long time this trade-off was acceptable because the alternative — building everything yourself — was too expensive.

4. AI reduces the cost of small pieces of software

AI does not transform software development by automatically building entire systems.

The real impact is more subtle:

the cost of small pieces of software decreases.

Tasks that previously required significant time can now be created much faster:

writing a small API integration
building a simple admin interface
implementing a validation rule
creating scripts that transform data

What once took several hours can now often be drafted in minutes and then refined.

This does not mean AI-generated code is perfect. But it changes the economic balance.

For many small features, custom solutions suddenly become viable.

5. WordPress as an example of this dynamic

WordPress is a good example of how generic software ecosystems evolved.

The platform consists of three core elements:

a CMS for content
a theme system for design
a plugin architecture for functionality

This allowed almost any website to be built by combining plugins.

A typical WordPress site might include:

an SEO plugin
a caching plugin
a form plugin
a security plugin
a custom fields plugin
a redirect plugin
analytics integrations

This works well. But it also means even simple sites can depend on dozens of external components.

AI introduces a subtle shift.

For smaller pieces of functionality, developers may increasingly choose to:

write a small function
use hooks
build a small integration

Instead of installing a plugin that does far more than necessary.

This does not make WordPress obsolete. But it may make plugin-heavy architectures less attractive.

6. Where generic software still wins

Generic software still has clear advantages in domains where:

infrastructure is complex
scale matters
maintenance is critical

Examples include:

payment systems
email infrastructure
logistics platforms
analytics services

In these cases the value lies not just in the code, but in the operational infrastructure behind it.

7. Where AI may apply pressure

AI will likely have the biggest impact on software that exists primarily because writing code used to be expensive.

Examples include:

small SaaS tools
plugin ecosystems
automation platforms
internal tools

These are the areas where developers increasingly say:

"We can just build this ourselves."

8. Summary: AI changes the economics of software

AI changes software development not only technically, but economically.

When the cost of small pieces of software decreases, the balance between:

using generic software
building custom solutions

naturally shifts.

This does not mean generic software disappears.

But it may mean that certain categories of software become less dominant than they were for many years.

Software systems may gradually move toward a combination of:

strong infrastructure services
smaller pieces of custom logic

3 common misconceptions about AI and custom software

1. "AI automatically makes custom software cheap."
AI speeds up coding, but design, testing, and maintenance still require expertise.

2. "Generic software will disappear."
In domains with complex infrastructure, generic platforms remain essential.

3. "Anyone can now build software with AI."
AI helps generate code, but designing and maintaining systems still requires experience.