# Enterprise Software Should Keep Up

A company changes every day. Its software changes once a quarter, if it's lucky. That gap is where most of the waste in enterprise software lives. It's been there so long that most of us have stopped seeing it.

Here's what it looks like. Say a bank's loan operations team gets a new rule from the credit committee: any small business loan above a certain size now needs a second review from risk. The decision takes an hour. Making the loan system follow it takes much longer. The rule touches the application form, the approval path, and the monthly report, and those live in three different systems. Someone files a change request. IT puts it in next quarter's plan, behind forty other requests that are just as reasonable.

The business can't wait a quarter, so it doesn't. A loan officer starts a spreadsheet. Every big loan goes on it. Someone emails risk, risk replies, and someone else pastes the reply into a notes field so the auditors can find it. It works. Then the committee adds two more rules, and the spreadsheet grows two more tabs.

Six months later the spreadsheet is the real system. The software everyone paid for is a place where loans get typed in after the actual decisions have been made somewhere else. Nobody chose this. It happened one reasonable workaround at a time.

## Enterprise software starts decaying on day one

Every company has a version of that spreadsheet. Usually dozens. They're what it looks like when enterprise software stops keeping up.

The odd thing about business software is that it's at its best on the day it launches. That's the day it matches the business most closely, because that's the day the requirements were written for. After that the business keeps moving and the software doesn't. Every new policy, product, reorg, and regulation opens the gap a little wider. Engineers call the gap technical debt. The people doing the work call it Tuesday.

![Illustrative chart: business needs and software start together at launch, then diverge as needs rise and delayed fixes leave the software behind.](https://content-calendar.live.gamma.sycamore.sh/api/v1/files/7d0c8r19c7w4atlj/enterprise-software-should-keep-up-01.png)

_Enterprise software and the business start together on launch day, then split. Every delayed fix makes the software fall faster, and the gap keeps widening._

Most business software is also built for the average company, so you pay for a lot you don't need and still lack the few things you do. And when one of those missing things matters, people don't wait. They build it themselves, outside the official system.

It's tempting to read that as people being careless. I think it's the opposite. They're doing their jobs. When the official software can't change as fast as the work, the work moves somewhere that can: a spreadsheet, a shared inbox, a side tool someone bought on a credit card. The company isn't failing. The software is.

## Why enterprise software doesn't keep up

The reason is simple. Changing enterprise software has always been expensive.

A change needs someone who understands the system, which is usually a few people. It needs to be built, tested, approved, and released, often across several systems that were never designed to work together. And it competes with everything else for the same scarce engineers.

Worse, each change makes the next one harder. Programmers have known this for fifty years. [The Mythical Man-Month](https://en.wikipedia.org/wiki/The_Mythical_Man-Month) states: "All repairs tend to destroy the structure, to increase the entropy and disorder of the system." Keep patching long enough and "each forward step is matched by a backward one." Software has to keep changing to stay useful, and every change makes it more expensive to change again.

So they ration it. That's what a backlog really is. It isn't a list of bad ideas. It's a list of good ideas that cost more to build than they were worth, at the price change used to have. The second review on big loans didn't wait because nobody cared. It waited because it cost too much.

![Comparison of change cycles: the old route passes through tickets, backlog and a later release; the proposed route describes a change, uses an agent to build and test it, and requires human approval before shipping.](https://content-calendar.live.gamma.sycamore.sh/api/v1/files/dxowye3hgsqczevr/enterprise-software-should-keep-up-02.png)

_The old process takes about a quarter per change. The new one takes about a day._

Seen this way, a lot of enterprise software history makes sense. Packaged software won because building was expensive. It was rational to buy a product designed for the average of thousands of companies and then bend your own company to fit it. Customization was more expensive than buying, and changing things later was the most expensive of all. So we learned to adapt to our software instead of the other way around.

Then SaaS made deployment cheap. You didn't need servers or an install team anymore. You signed up and started working the same afternoon. But SaaS kept the old assumption. It was still one product built for the average company, and now every customer ran the same version, which made it even harder to fit to how any one business actually works.

In my past experience, some of the best engineers I've worked with spent much of their time keeping what we had already shipped healthy, rather than building what came next. That's what happens when every change costs a lot and the number of changes only goes up.

## Cheap change becomes frequent change

That's what is changing now. AI agents can write software, test it, and change it, and they're getting better fast. [METR](https://metr.org/), a research group, measures how long a task (in human working hours) an AI agent can finish on its own about half the time. On software tasks, that length [has doubled roughly every seven months since 2019](https://metr.org/blog/2026-1-29-time-horizon-1-1/), and faster than that since 2024.

When something gets much cheaper, people don't just buy the same amount for less. They use far more of it. Change works the same way. When a change that used to take a quarter takes a day, you don't make your four big changes a year a little faster. You make hundreds of small ones. Modern cloud companies already make hundreds of changes a day, but those changes serve the average customer, not yours.

Small, frequent changes behave differently from big, rare ones. Go back to the bank. In the old process the credit committee makes its call and then waits a quarter to find out whether it was right, and by then the rule has already been worked around. In the new process the second review is live the next day. If the threshold turns out to be wrong, and too many loans pile up waiting for risk, the committee moves it on Thursday. Decisions get tested against reality in days instead of argued about for months.

Risk falls too, which surprises people. A big release that bundles a quarter's worth of changes is hard to test and hard to undo, and when something breaks you don't know which of the forty changes did it. One small change is easy to review, easy to check, and easy to roll back. In my experience, teams that ship small changes often break things less, not more.

And the software stops falling behind. Instead of fitting the business on launch day and drifting after, it follows the business continuously, because each decision becomes a small change soon after it's made. The gap in the first chart never gets a chance to open.

![Illustrative curves across successive changes: cost and risk rise in the old process, while both are depicted falling with small, tested and recorded changes.](https://content-calendar.live.gamma.sycamore.sh/api/v1/files/7w6t4zn9unt9s5uk/enterprise-software-should-keep-up-03.png)

_With the old process each change costs more and risks more than the last. With small, tested, recorded changes, both fall._

That changes how a company runs. When changing the software is cheap and safe, you stop treating decisions as permanent. You try things, see what happens, and adjust. The backlog stops being a waiting room and becomes this week's to-do list.

You might object that AI tools are good at demos and bad at real systems. That’s true of a lot of them. But the first launch was never the hard part. A company lives in every change after it.

The number that matters isn't how fast you can build version one. It's what the fiftieth change costs.

With ordinary software, each change costs more than the last, because each one adds to a tangle the next person has to understand. It doesn't have to work that way. If every change carries forward what the system already knows (the connections to other systems, who approves what, the tests that passed last time), then the fiftieth change should cost less than the first. That's the curve we're trying to bend, and it's something we intend to measure, not just promise.

## Two strands of the same thing

If changing enterprise software becomes cheap, a lot more software is going to change, and some of it moves money, touches customer data, or decides who gets a loan.

We've already seen a preview. AI agents are arriving in companies the way spreadsheets did: bought on credit cards, built inside teams, shipped inside other vendors' products. Often nobody has a full list and nobody clearly owns them.

So build and govern are strands of the same thing. You need both to run well. Speed without governance is reckless. Governance without speed is a ticket queue. Neither is a company you'd want to run.

Governing a change means it has an owner, a person who approved it, a record of what happened, and a way to stop it. When those come with every change, they don't slow it down. They're what make it safe to change things every day.

![Intertwined build and govern strands lead to one change, with an owner, a human approver, a record and an off switch.](https://content-calendar.live.gamma.sycamore.sh/api/v1/files/9gsx6hjq5pyfgo9t/enterprise-software-should-keep-up-04.png)

_Build and govern wind together into one thing. Every change carries both._

That's why we built Sycamore to do both from the start: build and change software, and govern it.

People often treat governance as the brake. I think it works the other way. Air traffic control didn't slow down aviation. It's what made flying at scale possible. The companies with the best controls will end up moving the fastest. Governance is speed.

For as long as there's been business software, companies have changed to fit it. That was never the right way around. It was just the only one we could afford.