The standard narrative is that accumulated software complexity equals competitive advantage. Years of iteration, domain knowledge baked into systems, specialized tooling - these were supposed to be what made incumbents hard to dislodge.
What they also are: maintenance burden, coordination overhead, and organizational inertia. Costs that were invisible when capital was cheap and hiring was the default answer to every scaling problem.
The shift is not subtle. A codebase that once represented a decade of competitive investment now also represents a decade of decisions that cannot easily be undone, abstractions that no longer match the business, and onboarding friction that slows every new hire down for months before they can contribute.
Meanwhile, the cost of building functional software from scratch has dropped faster than anyone modeled. Not to zero - enterprise feature depth still requires time and expertise. But close enough that "we have been building this for ten years" is no longer an automatic defense against a competitor starting fresh.
Large engineering organizations carrying large codebases are not necessarily stronger than lean ones. They may be slower, more expensive to maintain, and defending territory that better-tooled competitors can now approach from the outside.
Complexity compounds. The organizations that understood it as an asset are now discovering the other side of that sentence.
Thoughts? Find me on Bluesky.