Cursor, launching in just 2022, has been on an absolute blitz of a growth trajectory. Nobody has grown faster.

They have gone stratospheric. And ironically, the way that they left all the competition behind was beautifully simple: they made sure nobody had anything to leave behind.

Suiting that SpaceX bought themself this new rocket ship for $60 billion last week.

Cursor is an AI code editor and developer environment. It’s the window I run Claude Code in when making things. It’s the IDE on steroids that makes building stuff quite cracked if I’m being honest, and sometimes makes PMs like me step on some toes at work. Sorry team. ❤️

But as Uncle Ben said, “Peter, with great power comes great ARR”.

And they’ve stacked ARR faster than Slack, Wiz, Zoom, or Snowflake. Four MIT students who spent close to nothing on marketing to reach the first hundred million in revenue in less than 2 years. These guys absolutely killed growth (~9900% a year) with my personal favorite of all three utensils: the fork.

When I first started dabbling with Cursor and cosplaying as a developer, I remember actually asking an EM friend of mine why he’d moved his whole team onto Cursor in the early days. Why leave their VS Code ecosystem that they were established on?

His answer, in short was “we didn’t leave”. He told me “Cursor actually is VS Code”. And that in opening it up, all his extensions and shortcuts were already there, and it had AI built in. Nothing to set up.

The move was free. He opened a better version of the editor already on his machine, and everything he'd set up came along for the ride.

That idea sits behind some of the fastest-growing products, and through the right lens, might change how you look at your own.

The question is how much of your slow adoption is really your product, and how much is just the price a user would pay to leave whatever they already use?

And more so, how can you shift the thinking from “but there’s a switching cost!” to “stealing your competitions staying value”. And therein…their customers.

Tendem plugs expert human experts straight into the AI tools you already use, over MCP. You connect it once, then whenever a task needs a person instead of a model, you mention Tendem in the chat. It scopes and prices the job right there, and the expert sends the finished work back into the same conversation. No new tab, no re-explaining the job somewhere else.

I tried it on a previous newsletter edition. For $13, a human writer went through the whole thing and marked exactly where readers would drop off, where interest would spike, and left real, specific notes I could actually use. Start to finish, from AI handoff to human delivery, was under four hours.

Three things stood out:

It's the first time the "human plus AI" idea has felt like one motion instead of two separate tools. And it's built by Toloka, who have spent a decade doing human-in-the-loop quality for the frontier AI labs, so the expert bench is the real thing.

🥷 Stop building a better tool people have to switch to. Build on, from, or into the one they already use, so there's nothing to leave behind, then go deeper than the company that made it can follow.

A surface is everything we already touch to get our jobs done. In user terms, its the interface they’re familiar with, the quirks in the UI they’ve figured out, the shortcuts, add ons, the files and history they've piled up, the plugins and settings they've configured, and for some products, the place they spend their whole day already. All of it has real value to them, and walking away from it is the real cost.

Mostly this is called a switching cost, the friction of prying a user off the tool they know. e.g Atlassian to Linear; Sheets to Notion; Salesforce to Attio.

But it can be more useful to flip it around and call it staying value: the sum of everything a user keeps by not moving.

Same mechanic but read from the other side. And reading it from the user's side points you straight at the move.

You don't have to overcome a user's staying value. Instead, inherit it. Show up inside the tool they already use, carry over everything they'd otherwise give up, and put your real advantage one layer down, where the incumbent is stuck or hard to ever maneuver towards.

That’s a sales hook that says you only stand to gain without a tradeoff.

Cursor did this with precision by forking their competitor VS Code, and like that one emboldened friend at the table, used their fork to steal users from Microsoft’s plate.

VS Code is a free, wildly popular code editor Microsoft released in 2015. It became the default for a huge share of the world's developers, partly because it's fast and free, and mostly because anyone can write add-ons for it. There are hundreds of thousands of these extensions now, covering every language and workflow you can think of. A developer's VS Code is deeply personal by the time they've used it a while: their theme, their keyboard shortcuts, their stack of extensions, the muscle memory built over years.

Cursor is what happens when a small team takes VS Code's open-source code, copies it, and rebuilds the inside around AI. Since VS Code is open source, this is totally ok. And because Cursor left the outside almost identical, a developer opening it for the first time finds their familiar editor looking back at them, except now it can read their entire codebase, write across many files at once, and run as an agent that goes off, does a task, and comes back with the result. Same chair, new agent-first engine.

Forking only works when there's something forkable underneath.

A lot of the most important software in the world is open source, which means the code is public and you're free to take it, change it, and ship your own version. VS Code is open source. So is Chromium, the engine under Google Chrome. So is Postgres, the database a huge slice of the industry runs on, along with Linux, WordPress, and Blender. Anyone can fork these. That isn't some loophole it's literally the deal these projects offer on purpose to be extensible and cater to custom use cases.

A lot of other tools are the opposite. You can't fork Photoshop, or iOS, or Figma, or beehiiv, or Excel. The code is closed and copying it is off the table, so the surface is locked from a “we’ll just copy and paste and then remix what you made” perspective.

But forkability is more a spectrum thing vs a binary is-or-isn’t a switch. VS Code is close to an open invitation, licensed permissively and built to be extended, which is why most of the AI editors you know (Loveable, Bolt, etc) stand on VS’s shoulders.

Chromium is open too, but it's an enormous and gnarly codebase that takes real engineering muscle to fork and keep alive. If interested, here are 5 interesting forks of Chrome.

Forking isn’t the only option though. When you can't touch the code at all, there's a second door: you build on top of the platform through their API, the way an app lives inside Slack or sits on top of Gmail. You don't own the surface that way, but you still get to stand on it.

So the question isn't just "what could I fork." It's "what surface do my users already live in that I'm allowed to build on or into."

GitHub has Copilot and it's enormous. Microsoft owns VS Code outright. Both massive companies, so if this move is so good, why didn't the incumbents just run it themselves?

They tried. Copilot is that attempt. The question was never whether they'd respond. It's whether they could respond with the same move, and they couldn't, for reasons that have nothing to do with talent.

Take the numbers. Copilot reaches more than 20 million developers and sits inside 90% of the Fortune 100, pulling in somewhere around $300M a year. Cursor, with roughly a 1/20th of that user base, makes several times more. The gap there comes down to architecture more than reach. A plugin like Copilot can suggest the next line of code but it can't change how the editor reads your project. A fork can. That is the entire reason Cursor's multi-file Composer mode exists and Copilot has nothing like it: a plugin can only do what the host platform permits, and a fork can change the platform itself.

In GitHub’s case, Copilot lives as a feature inside VS Code, and a feature only reaches as far as the editor allows. To do what Cursor does, treating your whole codebase as context, editing across files, running an agent loop as a native part of the product, Microsoft would have to rebuild the core of VS Code itself. The moment they start, they put hundreds of thousands of extensions and millions of developers' muscle memory at risk. The stability and the sprawling ecosystem that make VS Code valuable are the same things that make it dangerous to crack open and rebuild. A four-person team with no users to protect can rewrite the engine on a Tuesday. Which they did. But Microsoft can't.

Jumping to the browser category…Google's constraint is different and even simpler. They could build an opinionated, AI-first browser. They won't though, because it would work against their own business. Chrome makes money by sending people out to the open web and showing them ads on the way. A browser that reads pages for you and answers in place sends fewer people out and shows fewer ads. So Google bolts on an AI sidebar and stops distinctivly short of rebuilding the browser around answers, because that rebuild would eat the thing that sponsors the whole Google party. This is the crux of counter-positioning: the other guy looks at your move, runs the math, and decides not to follow, because following would cost them more than ignoring you.

So what's defensible about a fork? On its own, intrinsically nothing. 40,600 forks of VS Code and you’ve heard of maybe 3 of them.

Anyone can fork open source, and plenty did. The fork isn't the moat. The fork is a wedge that allows you to get users from a competitor at near-zero switching cost. The defensibility is the incentive not to follow, and the window of time that buys you to do something else. Cursor's job was to spend that window building something durable: a proprietary model (Composer) to fix its thin early margins, a data flywheel from millions of users, and the brand as the new default.

TLDR: The fork can open the door, counter-positioning will hold it open, and what you build while it's open is the real moat that unhinges the door entirely.

Forking the rails hands you the technical surface: the extensions, the file formats, the plumbing. And there’s the second surface, the interaction layer, which is the habits and muscle memory a user has built. That's staying value too (for many types of products, you could argue more so even) and it's just as expensive to throw away. Cursor kept both layers intact—as you saw above, it looks and feels near identical. It inherited VS Code's internals and left the look and feel almost untouched so there was genuinely nothing to relearn.

Arc is the outcome when you half-cook this move. Not “bad” per se, but not "Elon is buying you for $60b after 4 years in business” good.

We wrote about them over at How They Grow. The Browser Company forked Chromium, so it inherited the whole technical surface, and it built something a devoted niche genuinely loved. But it also reinvented the interface (which was the UX moat they wanted to established), with a new way of handling tabs and navigation that asked people to relearn how to browse. By doing that, it handed the switching cost straight back, this time at the level of habit rather than infrastructure.

Arc won the enthusiasts because there was a community that wanted different right away. I was a fan. But they struggled to cross into the mainstream, and they eventually moved their energy to a newer AI-native browser—Dia.

TLDR: If you fork the rails but redesign the interface, the switching cost doesn't disappear. It just moves to the habit layer where it's harder to spot.

Even just to experience this new mode of precise working, Tendem are giving you $50 in starter credits to play with it. Click below, get your credits which definitely covers a task or two. For example, ask it to “clean and enrich this investor list — remove duplicates, fill missing LinkedIn URLs, flag anyone who invested in AI startups in the last 12 months.”

You get $50 starting bonus on signup · first 3 tasks 50% off · nothing charged until you approve the price. · Connects in less than 2 minutes

A few cases from products I actually use, and they split across the two versions of the idea: a) forking an open base, and b) moving into a rented place users already live.

I’ve used Cursor enough as a foundational example so I won’t say more here.
Let’s do Supabase first…

Supabase is Postgres (the open-source database millions of developers already know) wrapped in a modern and super usable layer: auth, storage, realtime, a clean dashboard. No new system to learn, no migrating off SQL. That’s the cookie-cutter version of the move: stand on the familiar thing so there's no new thing to move to.

What turned them into a rocket is a second kind of familiarity— that LLMs are fluent in Postgres and SQL because both are all over their training data. So when an AI agent like Cursor builds an app and needs a backend, it reaches for what it already knows, and Supabase made itself the most complete Postgres you can stand up in one shot with AI, then courted those builders directly to become the default they wire in.

The number of projects I’ve made in Cursor that have been stood up on Supabase, without me even opening Supabase, is insane.

Today more than 60% of new databases on the platform are spun up by an AI tool, Claude Code the single biggest source in 2026, and database launches are up 600% on the year. Firebase can't ride the same wave: it's proprietary, so the models never learned it as deeply, and Google can't make it the open default without unwinding the lock-in that is its whole model.

Takeaway: Your users' staying value now has a second owner—the AI building alongside them. Stand on what the models were trained on, and the agents writing today's apps reach for you without being told.

Not a fork, but same outcome. Viktor is an AI agent that lives inside Slack instead of in its own app. They reached around $15M in revenue in ten weeks and now sits in 13,000+ teams, and the strategic call akin to this move was killing their own web app two days after the data showed people falling for it inside Slack.

Why make your own surface when one is already there?

If you ask Viktor to build something in Slack and you wait three minutes for the result, that’s actually a totally fine experience, because Slack is where you’re already doing stuff. You just get another message from Viktor when you’re done. Ask the identical thing in a new unproven standalone web app and three minutes feels broken.

Same product, same output, but the surface you deliver on sets the expectation. Living in Slack as an app also handed Viktor 200M+ people's daily workspace, the context of the conversations already happening there, and a way to spread sideways as one teammate tags it into the next channel.

Takeaway: Where your product lives sets what users expect from it. What’s the right room for you? Is it a rented one you can join or your own to build?

Tendem's value prop is simple: take the work your AI got 80% of the way, and put a vetted human on the last mile to fix the mistakes and finish it properly. Before today, that lived in their own app. You did your thing in Claude or ChatGPT, then left to go paste it somewhere else and wait. Or you could used their Chat to start it.

Which is why their new MCP actually solidifies the whole pitch, because the problem it solves is born inside the AI tool you already use, and that's exactly where it wasn't.

So they made the move and now it plugs into your AI tools over MCP. You stay where you are, mention Tendem in the chat, and the human-finished work comes back in the same conversation. This is a bet to invest less in pulling users to their surface and rather moving onto the one we’re already on.

And that surface is real estate that barely existed two years ago. From asking things, to the MCP turning AI chats into a place you do things. I now drive Looker and PostHog more from inside an AI chat than from the actual products, and I'm not the exception. The work is migrating into the chat window, which makes "reachable from inside the chat" the new version of "lives in Slack" or "sits on top of Gmail."

Takeaway: Make your product something the agent can reach and run right inside the new default Chat surface your users are already in.

› Perplexity Comet. Built on Chromium so it gets extensions, bookmarks, and logins import in a click. The smart part is who can't follow: Google won't rebuild Chrome around answers because a browser that answers in place kills the search-ad clicks that fund the company.

› Superhuman. It never touched your email; it built a faster keyboard-first layer on Gmail, so your address, mail, and archive never move. The gap it aimed at is Gmail's own client, who won't chase the speed-obsessed power user because it's built for a billion average ones. Acquired by Grammarly for ~$825M in 2025.

I certainly have no plans to fork an editor or Chrome. Most of you don't either, and luckily you don't need to to get something from this. What Cursor actually stole wasn't VS Code's source—it was everything a developer would've had to leave behind to switch. And that exists everywhere as some of the examples above show, including in things you can't copy a single line of code from.

Your users are already working on various surfaces, even when it isn't code: the inbox they live in, the group chat where their people already are, the spreadsheet they've bent to their will, the camera roll filling up on their phone, the years of history in a tool they'd never re-key by hand, Claude. None of it is forkable. All of it is staying value. And in most cases, it’s something you can build on, sit beside, or read from instead of asking anyone to start over.

For example, in my app Little Moments, I was asking people to capture one moment a day going forward. Record real life from today. But our favorite moments are already captured in our camera roll, sitting there. So, leaning into the priceless history and UX of our camera roll, I created Magic Fill, allowing us to backfill moments, like

This isn’t 1:1 the move, but it translates. There was an asset with tremendous staying power (our photos), I was asking people to forget about it initially and come with me going forward (just take new ones), and decided to leverage that to create stickiness in my app (caption your photos and turn them into connected memories). The outcome is a new UX that makes my app much better and more valuable. See below if interested.

So far, 20% of users have tried this feature already, and completed the flow at a 60% rate.

So, for everyone without something to fork, the move is smaller and very doable. The feature list is a distraction, and so is the urge to bolt an integration onto someone else's platform because you can.

The real work is finding the one thing your user already has and would hate to lose, and building so they never have to.

› beehiiv runs The Diff, and it can run yours too — start a newsletter on the all-in-one platform I moved to, and use code THEDIFF30 for 30% off your first 3 months (Start a newsletter).

› My free builder tools do the math for you — an app revenue calculator, an app health calculator, and a competition calculator (See how your app compares).

› My Stack are the tools I actually use — the products I lean on to build things and run my business (Explore my stack).

› Missed the last 5-Bit Friday? (Catch up).