Mendix's CEO Says No-Code Is Dead. Lovable Just Hit $500M ARR. What's Actually Happening?

Two of the biggest names in enterprise low-code just announced, in effect, that their own product category is dying. Mendix CEO Raymond Kok says no-code is "on its last legs," being "snuffed out by vibe coding." OutSystems VP Miguel Baltazar says drag-and-drop no-code is "already on the decline." Read those two quotes together and you'd assume the visual builder is finished.

Now read the other headline. Lovable, a startup whose entire pitch is AI-generated apps, just crossed $500 million in annual recurring revenue and is reportedly raising $300 million at a $13.2 billion valuation. One of these stories is about a category dying. The other is about a category exploding. They can't both be true in the way the first one is being told.

> TL;DR

> Two enterprise low-code CEOs are declaring visual no-code dead. Lovable just hit $500M ARR and is raising at $13.2B. Visual no-code isn't dying; it's evolving into governed, AI-assisted platforms. The right question is which platforms survive, and the answer is governance baked in, not bolted on.

Is no-code actually dying?

No. What's dying is a specific product design: the blank-canvas visual builder where a human drags every element by hand. That design had a real moat for a decade, because hand-writing code was slow and a visual abstraction was faster. Then AI got good at generating code, and the moat started leaking. Kok and Baltazar are describing that leak accurately. Where they go wrong is describing the leak as if the whole category were the leak.

This isn't the first obituary, either. No-code has been declared dead roughly every eighteen months since 2015, usually by someone whose revenue model depends on you believing it. A prediction that keeps being wrong is worth examining before you repeat it.

Here's the thing those quotes miss. The moat of a serious low-code platform was never the drag-and-drop surface. It was everything underneath: the deterministic execution, the permission model, the audit trail, the ability to run a governed system without a full engineering team. The drag-and-drop was the front door, not the house. AI is replacing the front door. It isn't knocking down the house.

Why are the incumbents saying this?

Because it's convenient. "Our old product is dying, buy our new AI product" is an easier story to tell shareholders than "our old product still works but the market moved." Both Mendix and OutSystems are racing to add AI generation to their platforms. Declaring the visual builder dead makes that pivot look like survival rather than a forced march. I'm not saying they're wrong about the trend. I'm saying they have an incentive to declare the patient dead loudly, and a quiet incentive to keep selling the old product while they figure out the new one.

There's also a category-confusion problem baked into their framing. "No-code" in their mouths means "our enterprise low-code licence." It doesn't mean what a solo founder means when they build an app in Lovable over a weekend. Collapsing those two into one word is how you get the hot take "no-code is dead" while the no-code economy is setting records.

What's Lovable actually proving?

That AI-generated apps are a real business at real scale. $500 million in ARR is not a demo reel. It's a category-defining number, and it arrived fast. But look at what Lovable actually is. It's a governed, deterministic platform wrapped around AI generation. It doesn't hand you raw code and wish you luck. It handles deployment, state, and the runtime, and it wraps the model in a product. That's not the death of no-code. That's no-code with a different generator under the hood.

The irony is that the incumbents' own argument works against them. If AI generation is eating the visual builder, then Lovable is proof that a platform can ride that exact wave to half a billion in revenue. The question isn't whether AI kills no-code. It's why the companies that owned no-code let a startup take the AI transition away from them.

Why the timing matters

The $300 million raise at a $13.2 billion valuation is the signal to watch, because it tells you where capital thinks the market is going. Investors aren't betting that AI kills no-code. They're betting that the next generation of app platforms pairs AI generation with a governed runtime. That's not a bet against visual building. It's a bet that the builder is about to get an AI copilot and a stronger foundation, not a eulogy.

What does "governed" actually mean in practice?

It's a word I keep using, so let me be specific. A governed platform gives you four things natively:

• Permissions. Who can see, edit, and trigger what, down to the field level.
• Audit trails. A record of what changed, when, and by whom, including what the AI did.
• Deterministic execution. The non-AI parts of the app run the same way every time, so you can reason about them.
• Model abstraction. The ability to swap the AI model behind the feature without rewriting the app.

Those four things are what made enterprise low-code a real business in the first place. They're also exactly what ungoverned vibe coding lacks, which is why so much AI-generated code never makes it to production.

Which platforms survive the AI transition?

The test is one question: is governance baked in, or bolted on? Platforms where permissions, audit trails, and deterministic execution are native to the runtime survive. Platforms where they're an afterthought, added after the AI feature shipped, don't. The builders who win are the ones who can generate fast and verify faster. Speed of generation got commoditised the moment every platform added an AI button. Speed of verification didn't, and that's the new moat.

Here's a concrete way to see the difference. Two platforms both add "generate this app with AI." The first lets you generate, then edit a governed model where every field has a permission and every change is logged. The second lets you generate raw code that runs wherever, with no audit and no controls. Same feature on the surface. Opposite outcomes in production. The first is a platform. The second is a faster way to create a mess.

That distinction is the whole article in miniature. AI generation is now table stakes. The thing that separates a platform from a demo is whether the AI output lands inside a governed runtime or out in the open. Everything else is noise.

What should you do as a builder?

Don't panic-sell your stack because a vendor CEO wrote an obituary. Do run a simple test on whatever platform you build on: if the AI feature is stripped away, do you still have permissions, audit, and deterministic execution? If yes, you're on a platform that survives the transition. If the AI is the only thing holding the product together, you're building on sand, and the obituary was about you, not the category.

The takeaway

Stop asking "is no-code dead?" It's the wrong question, and it's being pushed by people who benefit from your panic. Ask instead which platforms survive the AI transition. The answer is the ones where governance is baked into the runtime, not bolted onto it after the fact. That's the platform worth betting on, and it's the exact opposite of dead.