Tool Anxiety and The Search for Stability in Business Automation

For a long time, building software was expensive. That meant that companies that successfully built a product could defend it with a combination of engineering effort, proprietary code, and network effects. Copyright wasn’t the only moat, but it helped: if writing the code took years, copying it wasn’t trivial.

Now something different is happening.

AI Is Making Software Cheaper

AI-assisted development is reducing the cost of producing software. Tools like Claude Code and similar systems allow developers to generate large amounts of boilerplate code quickly, accelerating parts of the development process.

Back in 2023, controlled experiments showed developers using Github Copilot completed programming tasks about 55% faster than those without it. (Emergent Mind) Nevertheless, real-world results were mixed and developers were highly skeptical.

Within two years, AI tools had reduced actual, real-world development time in some cases by 30–40% for repetitive work. (arXiv)

In 2026, AI generated code has become the norm. That doesn’t mean software is becoming effortless to build, but it does mean something important: the marginal cost of producing software features is falling.

When the cost of producing something falls, the supply usually rises. That’s exactly what we’re seeing.

The SaaS Supply Shock

Look across the SaaS landscape today and you’ll notice something striking: there are an enormous number of products doing very similar things.

In many categories, like project management, analytics, CRM, and automation, there are dozens or hundreds of competing offerings. This creates a kind of software supply shock.

When supply explodes, the marginal value of any individual product tends to fall. Even very good tools start to look replaceable, because there are so many alternatives with overlapping capabilities.

And that leads to a new psychological problem for businesses: tool anxiety.

When you adopt a piece of software today, you might reasonably wonder:

• Will this company still exist in five years?
• Will a better competitor emerge next year?
• Will I eventually have to migrate everything?

In the past, switching software was rare. Today it feels almost inevitable.

Software Is Moving Faster—Maybe Too Fast

At the same time, the pace of software development itself is accelerating.

That acceleration creates a competitive dynamic: every company is trying to ship faster than its competitors. The result is that software ecosystems are starting to look like arms races.

Every platform is expanding outward:

• The CRM becomes a marketing platform.
• The marketing platform becomes an analytics platform.
• The analytics platform becomes an AI platform.

Eventually every product is trying to do everything.

Ostensibly that's good for competition, but it's most certainly unsettling for businesses that depend on stability.

Businesses Need Stability

Companies don’t just buy software. They build systems around it.

Employees learn workflows. Data pipelines get built. Automations accumulate. APIs get integrated.

Once that happens, switching tools becomes painful.

So while software companies compete by moving quickly, their customers often want the opposite: predictability.

This creates a growing mismatch between how software companies operate and what businesses need.

The Rise of “Stable Glue”

One possible response is to treat software products as interchangeable, and instead focus on the layer that connects them.

Think of this as stable glue.

Rather than building your system around one dominant SaaS product, you build it around integration infrastructure such as automation tools, APIs, and data pipelines.

Platforms like n8n or Nango point in this direction. Their job is not to replace all your software, but to connect it.

If your architecture is built around that integration layer, switching tools becomes less catastrophic.

Instead of rebuilding everything, you just rewire the connections.

In other words, the durable part of your stack becomes the system architecture, not any individual SaaS vendor.

A Strange Centralization–Decentralization Paradox

What makes this moment especially interesting is that two opposite trends are happening at the same time.

On one hand, large platforms are trying to centralize everything into all-in-one ecosystems.

On the other hand, AI-assisted development is decentralizing software creation. Small teams can now launch products much faster than before.

So the supply of software is becoming more fragmented, even while companies promise more centralized solutions. That tension may define the next decade of software.

Some Practical Principles

If software markets are becoming more volatile, businesses may need a slightly different strategy for building their systems.

A few ideas seem increasingly important:

1. Own your data

Your data layer should outlive your tools.

2. Build modular stacks

Choose tools that can be replaced without rebuilding everything.

3. Invest in integration layers

Automation platforms and API orchestration tools can provide stability when individual products change.

4. Assume migration is normal

Instead of assuming software will last forever, design systems expecting that tools will change every few years.

The Open Question

This leaves us with an important, unanswered question:

In a world where software is becoming cheap and abundant, what exactly becomes the durable part of the system?

Not the apps. Those are increasingly easy to build, copy, and replace.

What persists is the structure around them: how systems are connected, how data is controlled, and how workflows evolve over time.

Even if AI eventually allows companies to generate most of their software on demand, the core problem doesn’t go away. Businesses still have to map ambiguous human needs onto precise, working systems.

That layer is where the real leverage will be, which is why we’re building for at Kaitelos.