Cursor Just Hit $4B in Revenue — Does No-Code Still Have a Reason to Exist?

Last week, Cursor crossed $4 billion in annualised revenue. That makes it the fastest-growing B2B software company in history. Four MIT dropouts, a code editor, and a number that makes Salesforce's early growth look sleepy. Meanwhile, Claude Code is doing $2.5 billion from a terminal tool. Lovable hit $200 million ARR in 12 months with 45 people. Forty-five.

The narrative has hardened into something close to consensus: AI coding tools are eating software, and everything that came before them is lunch. When you can describe an app to Claude Code and get a working prototype back in minutes, why would anyone spend time learning Bubble? Why configure a database in Stacker when Cursor can generate one from a prompt?

It's a fair question. The kind that makes no-code founders sweat. But it's also the wrong question. And the data that proves it arrived two days after the Cursor headline.

On June 10, Forbes published findings from a new MIT study covering more than 100,000 developers. AI coding agents write 180% more code. They ship only 30% more software.

That gap between code output and software shipped is the entire argument for why no-code still matters. Let's work through why.

Code is not software

This is the thing the AI coding narrative keeps missing. Typing code is the cheap part of building software. Always has been. The expensive parts are testing it, securing it, deploying it, monitoring it, fixing it when it breaks at 2 a.m., and explaining to your boss why the vibe-coded auth system leaked 40,000 customer records.

The MIT study captures exactly this. Those AI agents are churning out mountains of code (180% more), but most of it never makes it to production. It sits in pull requests that need review. It introduces bugs that need fixing. It creates security surface area that needs auditing. The code gets written, but the software doesn't get shipped.

I've watched this play out in real teams. A friend's startup adopted Cursor aggressively six months ago. Their PR volume went through the roof. Their deployment frequency? Barely moved. The bottleneck shifted from "can we write the code" to "can we trust the code." That trust step is not automatable in the way code generation is. It requires human judgement, testing infrastructure, and (here's the kicker) a system where you can visually verify what the thing actually does.

What structured no-code actually solves

When someone says "no-code is dead because AI writes code now," they're making a category error. They're comparing code generation to software delivery. They're the same kind of different as comparing a word processor to a published novel.

Structured no-code platforms like Bubble, Webflow, and Stacker don't compete on code generation speed. They compete on eliminating the downstream burden entirely. When you build something in a visual, deterministic platform:

You can see exactly what your app does. Not what the code says it does. What it actually does when a user clicks through it. That visual verification step that takes hours of testing in a vibe-coded app takes seconds when you can just look at the canvas.

Security and auth are built into the platform, not something you have to remember to add. The recent Red Access report finding 5,000+ vibe-coded apps leaking corporate data wasn't about bad developers. It was about a medium (raw code generation) that doesn't enforce security by default. Structured platforms do.

The behaviour is deterministic. When you drag a button onto a Bubble page or configure a form in Stacker, it works the same way every time. Compare that with prompting an AI three times and getting three different implementations, each with their own subtle bugs.

And the costs are predictable. You know what your platform subscription costs. You don't know what your vibe-coded app's technical debt will cost you in six months when the AI-generated architecture turns out to be held together with digital duct tape.

This isn't a philosophical preference for visual building. It's an economic argument about where the real costs of software live.

The maintenance crisis nobody's talking about

Here's a prediction that shouldn't be controversial: the explosion of AI-generated code is going to create the biggest software maintenance crisis the industry has ever seen.

We're generating more code than ever. Most of it was written by an AI that had no understanding of the broader system architecture. It was prompted into existence, tested lightly (if at all), and deployed because the demo looked good. Every line of that code is a future liability. Someone has to own it. Someone has to debug it. Someone has to explain to a compliance auditor why the payment processing logic wasn't reviewed by a human.

The tools winning the AI coding race (Cursor, Claude Code, Copilot) are still generating code that needs to be tested, secured, and maintained. They're making the front half of the problem (writing code) cheaper while making the back half (owning code) exponentially more expensive.

Structured no-code platforms are the counterweight to this. By eliminating raw code as the output medium, they eliminate the maintenance burden that comes with it. You're not maintaining an AI-generated React app. You're maintaining a configured platform instance where the platform vendor handles security patches, infrastructure scaling, and breaking framework changes.

That distinction (code you own versus configuration you control) is going to become the central axis on which build-versus-buy decisions turn over the next two years.

The takeaway

The AI coding boom doesn't make no-code obsolete. It makes the case for no-code stronger than it's ever been.

Every dollar Cursor earns is a dollar spent proving that people want AI-assisted building. That's demand that no-code platforms can capture too. But only if they stop apologising for not being code generators and start owning what they actually are: platforms that turn requirements into working, secure, maintainable software without leaving you holding a bag of generated code you can't trust.

The question isn't "does no-code still have a reason to exist?" It's "which platform solves the problem that the other side just made 180% worse?"

That's a question the no-code industry should be thrilled to answer.