Why Software Won't Die: SaaS, Vibe Coding, and Building on Probabilistic Ground

This is the fourth episode of Stolen Chat. Cao Liang spent seven years at Microsoft, living through three migrations in enterprise software — from on-premise to cloud to low-code. In 2020 he left to start Component.app. In two years, he rebuilt the product three times. Each time because the model got better, and he asked himself again: does what we've built still have a reason to exist?

We talked about why SaaS went sideways, what LLMs actually can and can't do, whether vibe coding platforms will survive, and why software itself isn't going anywhere.

SaaS went in the wrong direction

Cao Liang's take on SaaS is blunt: the industry lost its way.

The problem is cost structure. Building a SaaS product keeps getting cheaper, but sales and marketing costs are enormous — development is roughly 20% of total spend, sales is 80%. The part that actually creates value for the customer is that 20%. But because of go-to-market dynamics, 80% of the money goes to things that don't directly help the customer.

The second problem is rigidity. Standardized products work for narrow use cases, but the moment you try to extend horizontally, you need custom development. The business has to bend to fit the software, which works locally but breaks at scale.

Two interesting data points: the custom software development market is actually larger than SaaS — if SaaS volume is 10, custom development is 15 or even 20. And if you look at publicly listed US SaaS companies, the only truly massive ones are Salesforce and Workday. There aren't more.

SaaS's greatest value is domain knowledge. If that can be replicated at scale, and AI keeps advancing, the disruption will accelerate. AI didn't create SaaS's problems — SaaS was already hitting a wall.

Why enterprise software still feels terrible

Historically, it's actually improved a lot. If usability in the 1970s was a 1, the 2000s were a 5, the 2020s are a 20, and the next few years might reach 50 or even 100.

But the fundamental reason it still feels bad: building software is still extremely expensive. It's not just hiring a few engineers for a few months — you need continuous iteration, which means maintaining a team permanently. You need good product managers who understand business workflows. In developed countries, these people are very expensive.

Small businesses find it expensive. Large enterprises have it worse — they need to handle dozens or hundreds of scenarios, each requiring its own team, and organizational coordination complexity grows exponentially. A 30-person company might need two or three apps. A 3,000-person company might need hundreds.

"Do you believe in it?" — The moment he left Microsoft

When Cao Liang was pitching low-code products at Microsoft, he told a partner that software development would fundamentally change in the next ten years. The partner's boss looked at him and asked: "Liang, do you believe in it?"

He answered without hesitation: "Yes, I believe."

That night at home, he started thinking seriously — do I actually believe this? If I do, why am I not the one seizing this opportunity? If the next 10 to 20 years will see dramatic change, the best time to start is now.

He left in 2020. Started with low-code product distribution and services, broke into several major Singapore enterprises. But after a few years, he realized low-code products had their own limitations. In 2023, he decided to build his own product: Component.app.

Three rebuilds in two years: each time asking if the product should still exist

Component.app went through three major rebuilds. First generation: pure modular engine. Second: AI plus modular. Third: AI-native — use the LLM for everything it can handle, use proprietary modules only for what it can't.

Each rebuild was triggered the same way: the model improved, and they asked themselves — does what we've built still have a reason to exist?

"It's easy to fall into self-reinforcement — 'our product is great, the model has weaknesses, it can't replace us yet.' But that thinking leads to a dead end. So we flip it: can the model's strengths suppress its weaknesses? If yes, then we have no reason to exist."

"If this thing has no value, shut the company down today. Don't justify yourself on the wrong path."

LLMs are fundamentally probabilistic

This was the core judgment of the episode.

Cao Liang argues that LLMs are fundamentally probability-based computation, deeply dependent on existing data. Two conclusions follow:

First, LLMs don't have logical reasoning capability. Despite having "reasoning" features, those are probabilistically simulating human reasoning processes. The proof: if LLMs actually had logical capability, we wouldn't need to build so many Agents. The entire Agent ecosystem, harness engineering — these exist precisely because AI lacks logic. We have to build a logical framework outside its "brain."

Second, LLMs can't create the future. They accumulate past successful experiences; they can't invent new programming languages or new development frameworks. Creation is still a human job.

How do you coexist with an unreliable technology? Treat the model as a tool, not a person. As a tool it's excellent — provided you have a complete knowledge framework yourself. But you can't hand something off and walk away. It's not yet at human level.

Will vibe coding platforms get crushed by the model?

Cao Liang's assessment of platforms like Lovable and Cursor is sober: successful now, but the uncertainty ahead is enormous.

Break it down: roughly 10-20% of their value comes from their own engineering systems, 80-90% comes from the LLM's coding ability. After Claude Code launched, the shift was visible — people he knows at big tech companies who used to prototype with various vibe coding tools have all switched to Claude Code.

"Companies built entirely on model capabilities, standing just slightly ahead of the model's wheels, will very likely get run over."

Same goes for document tools. Once GPT enriches its document capabilities, those companies will face serious challenges.

Software won't die

His answer was immediate: no, it won't.

Software's essence is operating data. Strip away Taobao's fancy UI, make it look like an early BBS forum that just manipulates data, and people would still use it. AI interaction is actually inefficient — if I want to see a sales report, opening the software gives me a dashboard instantly, which is far better than having AI re-query it every time.

AI interaction is most efficient only in ambiguous scenarios, like customer service. But for operating, interacting with, and presenting data, the best medium is still a program.

Southeast Asia can't support this market

His judgment: it's tough.

Enterprise software demand comes from two factors: business complexity — more mature businesses need more software to compress headcount; and GDP per capita — only high-wage markets need software to replace people. For the same cost, add a person or add software? If wages are low, adding people always wins.

So Component.app will eventually move to developed markets. Short-term: do well in Singapore. Medium-term: expand to developed countries, and gradually move toward larger enterprises.

Losing generals think about how to win. Winning generals think about how they could lose.

We ended on his habit of constantly overturning his own assumptions. Adding a new capability is easy — a year or two. Changing your mental model is the hardest thing — it takes immense effort and pain.

He reads military history. When two armies face each other, the one who can first think from the opponent's perspective — figure out how the other side could beat them — that person tends to win the longest. Losing generals focus on how to beat the opponent. They never think about how the opponent could beat them.

"Building products is the same. You have to keep overturning your own assumptions. You need the courage to say: I was wrong. Better to shut the company down than justify yourself on the wrong path."