So anyway, let me tell you about the robots.
In 1950, Detroit employed over 220,000 auto workers. Good union jobs. Good wages. By 1970, half of them were gone. Not to Mexico. Not to China. To robots and assembly line automation that simply didn’t need much human labor. By 1982, another 400,000 jobs disappeared in just four years. Cities hollowed out. Communities devastated.
Here’s the part that surprised me. Cars didn’t get cheaper.
All that productivity. All that automation. A robot-hour costs $3–6. A union autoworker costs $35–55. You’d think the consumer would be swimming in affordable vehicles. Nope. In real, inflation-adjusted terms, car prices held roughly steady. Vehicle price inflation ran about 2.4% annually over the last 90 years — below the overall inflation rate of 3.5%. So technically, yes, cars got relatively cheaper. But you weren’t getting a deal at the dealership.
What you got was a better car. The 1970 Ford Maverick cost about $1,900. Call it $15,000 in today’s dollars. No airbags. No ABS. Drum brakes. Optimistically, it might run for 80,000 miles if you didn’t live somewhere they salt the roads. Today you get a $25,000 car with more computing power than the Apollo program, 200,000-mile reliability, and enough safety systems to make it genuinely hard to kill yourself. The productivity gains went into quality, not price reduction. The consumer won. Just not in the way they expected.
The companies that didn’t automate didn’t get a choice about their future. British Leyland — the UK’s noble attempt at a European GM — was a sprawling mess of brands that couldn’t, or wouldn’t, invest in modernization. Poor management, constant strikes, outdated models. By the 1980s companies that didn’t adapt were being sold for parts. AMC got absorbed by Chrysler in 1987. Chrysler didn’t want AMC. They wanted Jeep. Studebaker just disappeared.
The lesson from Detroit seems straightforward. Automation doesn’t lower prices. It raises quality, crushes laggards, and rewards early movers. The ones who saw it coming thrived. The ones who thought they had more time didn’t.
The same wave is hitting business software right now. And most people are drawing the wrong conclusions from it.
My clients hear it constantly — AI is going to drive software prices down. It hasn’t happened. Salesforce isn’t lowering its subscription price because GitHub Copilot made its engineers more productive. Microsoft isn’t discounting M365 because it costs less to build. They’re adding features, calling it innovation, and renewing contracts.
There’s a reason for this that has nothing to do with greed and everything to do with math. Public companies need to show growth. A smaller Salesforce with lower prices and the same margins isn’t a story Wall Street rewards. So productivity gains go somewhere else — margin expansion, feature velocity, acquisitions, shareholder return. The customer gets a better product. Nobody gets a cheaper one. Detroit figured this out decades ago. The auto industry’s gains went to exactly the same place. Consumers got safer, more reliable cars and the sticker price kept climbing. Same logic. Same outcome.
Here’s what makes it structural rather than cyclical — it’s not just one company making this choice. It’s the entire category making it simultaneously. When all the competitors face the same Wall Street pressure, the whole market inflates together. Competition alone won’t force prices down if every player in the room has the same incentive to absorb the gains elsewhere.
Detroit could absorb its productivity gains as margin and feature creep because no one could threaten them from below. Building a car company requires billions in capital, manufacturing plants, supply chains, dealer networks, and crash safety certification that takes years to earn. Nobody was launching a new automation-only car company in 1975. The capital requirements made it impossible.
Software doesn’t have that protection. A five-person team with AI tools can now build what required fifty engineers three years ago. The cost to launch a credible software product has dropped by an order of magnitude. That’s not a gradual shift — it’s a structural change in who can compete. The moat that protected the incumbents was never really the code. It was the cost of writing it.
Or so it seems.
Let’s be precise about what that actually means. Because I think we’re collectively underestimating something important.
The moat didn’t disappear. It moved.
Software is codified business logic. Every enterprise system in production today is the accumulated result of thousands of decisions — edge cases, workflow exceptions, compliance accommodations, political compromises — translated over years into system behavior. That’s not code. That’s institutional knowledge wearing code’s clothing. The code was always the cheaper part of the problem.
The expensive part is the analyst layer. The people who understand why Salesforce is configured the way it is at a specific company. Who made those decisions. What business rules they encode. Which rules are still valid and which are legacy artifacts that nobody remembers the reason for but everyone is afraid to touch. That knowledge doesn’t live in a repository. It lives in people, and often, just barely.
AI makes this more acute, not less. If code becomes cheap to write, the constraint moves entirely upstream. You can generate code all day. You still need someone who can translate messy, contradictory, politically charged organizational reality into clean requirements. That was never a technical problem. It still isn’t.
So the new entrant’s real challenge isn’t building the platform. It’s earning the right to re-encode twenty years of business logic that the incumbent already has, imperfectly but functionally, running in production. That’s a formidable climb.
And here’s the thing about that climb. Nobody is going to move for a product that gives them 90% of what they need in a critical system. Selling a CRO a 90% effective CRM is like asking someone to breathe for 90% of the day. It sounds fine until you realize that’s holding your breath for the last two and a half hours. The bar isn’t “build something good.” The bar is “build something complete enough that a CRO will stake their number on it.” That’s a risk evaluation, not a feature comparison. The moment a deal slips through a gap in the system, the vendor isn’t getting a support ticket. They’re getting ripped out.
The reason incumbents hit 100% isn’t that they wrote better code. It’s that they’ve been filling gaps for twenty years. Every edge case that fell through got reported, escalated, and eventually patched. The new entrant doesn’t know what they don’t know. And in a critical system, what you don’t know kills you.
Some of my clients have reached an even bolder conclusion. Skip the new vendors entirely. Build it ourselves. We have smart people. We have AI tools. How hard can it be?
I’d ask them one question before they start writing the check.
Who’s building your ecosystem?
Consider what happened with Microsoft Office and Google Workspace. Google built a truly competitive product. Docs, Sheets, Slides — clean, fast, collaborative, and in some ways, technically superior. Free. Yet enterprise after enterprise stays on M365, and the numbers keep going up. Not because Word is better than Docs. It’s that the ecosystem around M365 is so deep that leaving means giving up everything built on top of it. Every macro, every template, every third-party integration, every workflow, every compliance tool, every IT team trained on it for the last twenty years. Microsoft didn’t win with a better product. They won because the community finished the product in ways Microsoft never could have internally.
Nobody is building their own word processor. Nobody should be building their own CRM either. They just don’t know it yet.
A Fortune 500 that builds its own business software has exactly one contributor finding and filling gaps — itself. Every edge case is an internal project competing for budget and headcount. Every missing workflow is a ticket in a backlog. The incumbent has had thousands of customers surfacing gaps for decades. The self-builder has a steering committee.
None of us is as strong as all of us. That’s not a platitude. It’s the kill shot to the self-build argument.
The self-build instinct makes sense on a spreadsheet. License cost times seats times years equals a big number. Build it once, own it forever. The math looks compelling right up until you account for the ecosystem you’re walking away from to pursue one you’ll never have.
So where does this actually land? What does the next generation of business software look like?
Not a cheaper version of what already exists. Building a cheaper Salesforce is a race to zero. If your only differentiator is price, you’re a commodity the moment someone builds the same thing for less, which with AI tools, is increasingly a matter of months, not years.
The winners will look less like Salesforce and more like AWS. Build the hardened, opinionated core. Expose the platform completely. Let customers, partners, and developers build things you never anticipated — because it serves their business to do so. The community becomes the product. And the community is what closes the gap from 90% to 100%.
Data access is the on-ramp to that community. Closed platforms don’t attract developers. Restrictive APIs don’t inspire partners. Customers held hostage to their own data don’t evangelize. My clients aren’t frustrated with software pricing alone — they’re frustrated with being held hostage to their own data, paying extraction fees, fighting rate limits, begging for integrations. Any platform that solves that doesn’t just win customers. It builds a community.
Switching cost isn’t the software anymore. It’s leaving everyone you built with behind. That’s a moat the incumbents understand and the challengers need to earn from day one.
In 1936, France completed one of the greatest engineering achievements in military history. The Maginot Line was a continuous fortification along the Franco-German border — concrete bunkers, retractable gun turrets, underground railways. Hundreds of miles of it. Essentially impenetrable.
In 1940, Germany went around it.
The French had built a perfect defense against the last war. The threat they prepared for never came. The one that did attacked from a direction the fortress was never designed to face.
The incumbents in business software have built a genuine fortress — twenty years of accumulated business logic, a mature ecosystem, and switching costs that make displacement difficult. They’re defending against the threat they expect: a cheaper, faster version of themselves built on AI. That threat is real but manageable. The one that really matters comes from a different direction. An AI-native platform that builds the core, opens the data, and lets the community finish the product in ways no internal team ever could.
But Germany’s real problem wasn’t the Maginot Line. That was just the opening act.
After going around France’s great fortress, Germany turned east and ran into something it had no framework to defeat. Not a wall. Not a line. Russia.
The Soviet defense wasn’t geographic. It was metabolic. In 1941, with the invasion already underway and catastrophic early losses mounting, the Soviets relocated over 1,500 factories east of the Urals and kept producing. By 1943 they were outpacing German tank production by nearly three to one. The more pressure applied, the faster the output. The harder Germany pushed, the more Russia produced. There was no flank to exploit. The defense wasn’t a position to be bypassed — it was a system that grew stronger under attack.
This is the moat that matters in business software. Not the code. Not the cost of writing it. What comes after is the ecosystem. And the most important part of that ecosystem isn’t the vendor. It’s the customer.
Here’s what gets missed in every conversation about enterprise software disruption. JPMorgan employs more technologists than Microsoft. Citi armed 30,000 developers with AI coding tools in 2024 alone and spent nearly $12 billion on technology. These aren’t helpless organizations waiting for a vendor to solve their problems. They are formidable engineering operations with deep domain expertise. What they can’t do — and shouldn’t try to do — is build the foundation. The hardened core that takes twenty years to get right.
But give them that foundation, with open APIs and real data portability, and they’ll close the gap from 90% to 100% themselves. They don’t need the vendor to anticipate every edge case. They’ll solve their own edge cases. That’s not a community of passive consumers waiting for support tickets to get resolved. That’s 30,000 engineers at one bank alone, building on a platform designed to let them.
That’s the Soviet manufacturing surge applied to software. The capacity was always there. It just needed the right conditions to mobilize. And when it does, the platform that enabled it becomes indispensable — not because customers are locked in, but because they’ve built half the product themselves and they’re not leaving their own work behind.
You can’t go around it. You have to out-produce it. And the defender gets stronger as the pressure mounts.
Price is a tactic. Community is a strategy. Completeness is the price of admission.
The ones who get that wrong don’t end up in a museum. They end up in the dustbin.
Ken Phelan is the CTO of Gotham Technology Group, a technology consultancy serving enterprise clients in the NY/NJ metro area.