A new code host from a company known for its AI editor is, by itself, worth paying attention to. Cursor started rolling out Origin on Monday morning — a real code hosting and collaboration platform, going first to paid Cursor users. Three and a half hours later, GitHub's status page turned red for six hours and forty-two minutes. The two events are unrelated. The fact that they hit the same news cycle is the cleanest possible argument that the place your code lives is infrastructure, and infrastructure has outages.
This is genuinely good news for builders, and the practical version of "what do I do about it" is the rest of this post.
A lot of "code hosting" announcements from non-platform companies end up being a read-only mirror or a thin wrapper around someone else's host. Origin isn't that. Cursor shipped it as version control and collaboration with the surface area you'd expect — repos, pull requests, permissions — gated behind paid Cursor tiers.
What's interesting is that an AI editor vendor decided the workflow layer under the editor was worth owning. Not the model. Not the chat sidebar. The repo, the diff, the merge, the deploy hook. Cursor's bet is that the AI and the host are part of the same product surface, and that if you write code in their tool, you'll commit code in their tool too.
That's a meaningful bet, and it's the kind of move that puts real pressure on GitHub's editor integrations and pricing over the next year.
GitHub's own incident log, as reported on the day's events, reads like an inventory of everything a developer needs on a Monday:
That's not one service failing. That's the whole loop. You can't merge. You can't open a PR. You can't curl
a tarball out of a release without retrying. And the AI assist you'd normally fall back on during a manual recovery is itself hosted on the same provider that's failing.
Six hours and forty-two minutes is the kind of number that gets platform-risk meetings scheduled. It's also the kind of number that doesn't need to happen often to justify at least running the alternative in parallel for a week.
The SSO failure deserves its own callout. For enterprise teams, "the host is down" is annoying; "we can't even authenticate to the host" is a Monday-bleeding-into-Tuesday incident. SAML, OIDC, SCIM, Team Sync — all four failed. That's the worst single category in the whole log, because auth is the gate everything else sits behind.
The two events are not coordinated. Product launches get locked in weeks ahead, and nothing about Cursor's rollout suggests they were waiting for a status page to turn red. But a GitHub competitor shipping its own host on the same day GitHub buckled is the kind of accident that turns a quiet paid-user rollout into the most-watched code hosting news of the week.
Vercel's chief executive weighed in publicly. A Cursor employee posted a line that, per the reporting, "writes its own headline." The exact wording isn't in the piece I'm working from, so I won't pretend to quote it — but the pattern is familiar: when one provider stumbles, the competitor's launch gets an audience it didn't pay for.
The lesson is not "switch hosts." The lesson is "stop pretending you can't."
The rollout is gated behind Cursor's paid tiers. The article I'm working from doesn't list a public sign-up URL or pricing page, so the specifics below describe the shape of the workflow rather than a copy-paste recipe — Cursor will hand you the actual remote URL when you create a repo.
git remote add origin <the-url-origin-gives-you>
git push -u origin main
git clone --bare git@github.com:your-org/your-repo.git
cd your-repo.git
git push --mirror <the-url-origin-gives-you>
A few practical notes:
There are no public benchmarks on latency, reliability, or cost-to-host between Origin and GitHub yet. Cursor hasn't published numbers, and any specific figure I'd write here would be invented. That's the thing to actually watch over the next 90 days.
Here's the part that doesn't move when Cursor ships Origin, when GitHub ships a new pricing tier, or when the next outage sends everyone shopping for backups: the UI your users touch. The component that renders on iOS, Android, and the web. The API your screens call. The visual contract you shipped in your last release.
[[DIAGRAM: model provider → editor → code host (GitHub or Origin) → repo → UI component → web + iOS + Android]]
A code host is one layer of a stack. So is an editor. So is a model provider. None of them are the layer your customers interact with. That's the component layer — and it's the one piece of the system whose design should not depend on where the commits live.
That's the part of the build OTF sits under. When your repo lives on GitHub today and Origin tomorrow — or both at once for a quarter while you decide — the same Button
, Dialog
, and Sheet
on web and native doesn't need to know. One component, one API, web + iOS + Android, behavior and styling identical across all three. Swap the host underneath, the screen above doesn't flinch.
Convention beats configuration here. Pick the layer that's stable across vendor churn, push as much of your build into it as you can, and the next outage is a Monday-morning inconvenience instead of a Monday-afternoon rebuild.
A new host means new competitive pressure on pricing, on reliability SLAs, and on how tightly the editor and the host integrate. That's good for builders — every announcement that nudges GitHub on any of those axes is a tailwind for everyone shipping code.
Four things worth tracking:
The durable part through all of it: the cross-platform UI layer that survives the swap. When Origin earns real adoption, or when the next host earns it after that, the work that doesn't have to change is the work that compounds. One codebase, web and native, the same component on every surface. Build that once, and the next outage is a Tuesday-morning story.