AIChatGPT, Claude, GeminiSoftware & SaaS

$600M in annualized revenue on code nobody's engineering team wrote

Lovable just crossed $600M in annualized revenue, and the apps built on its platform are pulling nearly a billion monthly views. That number is worth pausing on, because it traces back to an idea about programming that most engineers spent years dismissing.

Neo NeumannNeo NeumannAI Practice LeadSeptember 24, 2026

Listen to the podcast

4 min

Chapters

Key takeaways

  • Treat annualized revenue as a snapshot of one good month multiplied by twelve, not a bank statement.
  • Ask how many apps carry the headline view count before calling it a healthy ecosystem rather than a lottery.
  • Discount OpenAI and Google figures on model-generated code, since both sell the tools doing the generating, and cross-check before quoting them.
  • Ship the prototype with Lovable or similar and get it in front of users this week, but ask who reads this code in six months when it breaks.
  • If you build software for a living, move your value toward maintaining and scaling live systems, not writing version one.
Read the full transcript

Host:Welcome back to Leaders Insights. $600 million in annualized revenue on code nobody's engineering team wrote, and why it matters this week. Most of the code running, lovable's $600 million business is garbage. And that's exactly why it works.

Expert:You're half right, which is the most dangerous place to be. The code is often mediocre. That mediocre code that ships beats beautiful code that sits in a branch nobody merged.

Host:Let's take that $600 million apart, because it's an annualized figure and those are slippery. What's actually inside it?

Expert:Annualized means they took a good month and multiplied by 12. So treat it as a snapshot, not a bank statement. The real tell is the near-billion monthly views on apps built with the platform. Views mean the output isn't dying in a demo. Someone's using these things. Or someone's spun up a thousand throwaway apps and the view count is vanity. That's the crack I'd pry open first. A billion views across how many apps? If it's 10,000 apps averaging 100,000 views, that's a healthy ecosystem. If it's 50 apps carrying the whole number, you've got a lottery, not a business. Lovable hasn't broken that down publicly. And until they do, I'd hold the champagne.

Host:So the metric that everyone's quoting is the one you trust least.

Expert:The revenue's fine. That's the story people wrap around it that's junk.

Host:Everyone's saying, look, AI writes software now, engineers are obsolete. That's the consensus. And it's lazy. Make the case that it's wrong. Because $600 million is a loud argument.

Expert:Here's the distinction nobody's making. Lovable isn't replacing engineering. It's replacing the blank page. The hard part of software was never typing the code. It was knowing what to build and getting version one in front of a human. That's the part the model does well. The part it does badly is the part that shows up at month six.

Host:Define month six.

Expert:The moment your app has real users, real data, and something breaks at 2 AM, the model that generated your login flow doesn't know why sessions are dropping under load. Someone who actually understands the stack, the layers of software from the database up, has to walk in and read code they didn't write. It's a worse job than writing it fresh. And it's the bill coming due on all of this.

Host:You're describing technical debt with a smile on its face.

Expert:Debt. The shortcuts you take now that you pay for later with interest. And AI-generated apps take on debt faster than any junior developer I've ever managed. Because the machine has no shame and never gets tired of making the same mistake.

Host:OpenAI and Google both publish numbers on how much code their models now generate. How much of that do you buy?

Expert:OpenAI has said a large share of code in some companies is now model-assisted. And Google's made similar claims about its own engineers. But both sell the tools doing the generating, so those figures are marketing dressed as research. There's no independent audit I'd stand on today. Cross-check before you quote them.

Host:Then what's the honest read on lovable success?

Expert:They found the customer everyone ignored. Not the engineering team, the founder, the marketer, the person with an idea and no CS degree. That buyer never had access to software creation before. Lovable didn't beat the engineers. It went around them to a market that was starving.

Host:And when those apps hit month six?

Expert:Some die. Some hire a real developer to clean up the mess, which, funny enough, means the tool that was supposed to kill engineering jobs is generating them, just downstream and grumpier.

Host:So the contrarian take is that lovable proves engineers matter more, not less.

Expert:It proves the value moved. Away from writing the first version toward maintaining and scaling the thing once it's alive. If you're a developer panicking about your job, that's where you run.

Host:Give me the one thing a listener does with this tomorrow.

Expert:Build your prototype with lovable or anything like it. Get it in front of users this week. But before you write a line of real business logic, ask one question. Who reads this code in six months when it breaks? If the answer is nobody, you don't have a product. You have a countdown.

Host:Sources for today's episode. TechCrunch AI, the decoder. Ours Technica AI. KD Nuggets, Google AI, vendor, AI Lab. Open AI, vendor, AI Lab. That's your five. The full AI track, structured and free of fluff, is at MBA-training.com.

Before vibe coding had a name, the assumption was simple and rarely questioned: software gets built by people who can write software. You either learned to code, hired someone who did, or you waited. Product managers wrote specs and handed them to engineers. Founders with ideas but no technical background spent years either learning Python on weekends or burning equity on developer salaries. The gap between having an idea for a digital product and shipping one was, by default, measured in months and thousands of dollars, at minimum.

That was not a law of nature. It was a consequence of the tools available.

What is vibe coding and who coined it?

The phrase "vibe coding" was coined by Andrej Karpathy in early 2025. Karpathy, a founding member of OpenAI and former head of AI at Tesla, posted a description of a new way he was working: describing what he wanted in plain language, letting an LLM generate the code, and largely ignoring the underlying implementation. He called it "fully giving in to the vibes." The post spread quickly because it named something developers had already started doing informally, and because it arrived at exactly the moment when code-generation models had become good enough for the workflow to actually hold together.

The timing was not coincidental. Models like GPT-4 and Claude 3 had crossed a threshold where they could generate coherent, functional code across a wide range of tasks, not just autocomplete snippets but whole components, full routes, connected logic. That capability had been accumulating for a few years, but it took a recognizable name and a credible voice to crystallize it into a practice people could talk about and build products around.

Lovable, the Swedish startup formerly known as GPT Engineer, was already moving in this direction before Karpathy's post. The product lets users describe an application in natural language and receive a working web app. No IDE, no local environment, no version control to configure. By mid-2026, Lovable's co-founder Fabian Hedin reported that the platform had crossed $600M in annualized revenue, and that apps created on it were receiving nearly a billion monthly views. Those are not prototype numbers. That is production traffic on software that, in most cases, was built without a single line of hand-written code.

Where the real friction in software development lived

What makes the Lovable trajectory interesting is what it reveals about where the friction actually lived in software development. The assumption had always been that the hard part was writing code. Vibe coding platforms suggest the hard part was everything else: knowing what to build, describing it clearly, iterating on feedback, getting something in front of users fast enough to learn from it.

Those are skills that exist in abundance outside engineering teams. Product managers, consultants, marketers, operations leads, and founders without technical backgrounds have spent careers developing exactly this kind of thinking. Vibe coding does not give them a shortcut around software; it gives them access to a process they were already equipped to drive.

The category has also matured faster than skeptics expected. Early vibe coding outputs were easy to dismiss: toy apps, visual demos that broke under real conditions, UIs that looked fine and did nothing. That critique still applies to some portion of what gets built today. But the billion monthly views on Lovable's platform suggest a non-trivial share of what ships is useful enough that real users keep returning to it.

Understandinghow agentic coding systems actually operate behind the scenes helps explain why quality has improved. The better platforms now run multi-step agent loops: generating code, testing it, catching errors, and revising, without user intervention at each step. That is architecturally different from a single prompt returning a static code block.

The question of output quality has not gone away, though. A billion monthly views says something about volume and reach; it says less about security posture, data handling, or what happens when an app built in forty minutes starts processing real customer information.Knowing how to evaluate whether what an AI system produced actually works is a distinct skill from knowing how to prompt it, and it is one that vibe coding platforms cannot substitute for.

Why COBOL, 4GLs and low-code never closed the gap

The origin story here is not really about Lovable, or even about Karpathy's 2025 post. It goes back further, to decades of failed attempts to make software creation accessible to non-programmers. COBOL was partly motivated by the idea that business users should be able to write their own programs. Fourth-generation languages in the 1980s made similar promises. Low-code tools in the 2010s got closer but never escaped the gravitational pull of complexity: sooner or later, you still needed a developer.

What changed this time is not the ambition but the mechanism. Large language models can hold enough context, generate enough coherent structure, and iterate fast enough that the gap between description and working software has collapsed in a way earlier tools never managed.

For a professional who is not an engineer, that shift has a practical implication worth sitting with: the bottleneck in building digital products has moved. It used to be technical skill. It is now clarity of thinking and quality of judgment about what good output looks like. Those are learnable, and they were already your job.

Lovable's $600M run rate was built on people who had ideas, described them well, and shipped. The engineering credential was not the constraint. It never was.

Go deeper

The lessons that take this article further, free to read.

  1. 1ChatGPT for coding and canvasChatGPT & the OpenAI ecosystem
  2. 2Codex: agentic coding in your environmentChatGPT & the OpenAI ecosystem
  3. 3Claude code: an agentic coder in your terminalClaude & the Anthropic ecosystem
  4. 4Agents vs workflows vs automations: choosing the right level of autonomyAI agents: design, build & operate
  5. 5Evaluating outputs: how do you know it works?Building with AI

Finished reading?

Validate your read to earn XP and feed your radar.