Cursor Wants to Be Your GitHub Now

For fifteen years, GitHub has owned the place where code lives. Not dominated — owned. Competitors existed, but the question of where a serious project hosts its repository stopped being interesting around 2012.

That’s shifting. Cursor, the AI coding company that went from side project to industry fixture in about two years, just announced Origin — its own code hosting service. Around the same time, a thread landed on Hacker News asking, essentially, what’s going on with GitHub lately. Those two events look unrelated. They aren’t.

One caveat before we go further: the broader community signal here is thin. There’s no substantial Reddit discussion from the past month, and X data wasn’t available. So this is structural analysis, not a survey of developer sentiment. Treat specific numbers with appropriate suspicion — nobody outside these companies has them.

Why a Code Editor Company Builds a Git Host

On its face, this is a strange move. Cursor makes an editor. Repository hosting is a capital-intensive, low-margin, operationally brutal business. Why touch it.

The answer is agents.

AI coding has moved well past autocomplete. An agent now reads an issue, cuts a branch, edits files, runs tests, and opens a pull request. It walks the exact workflow a human engineer walks. And every stage of that workflow happens on GitHub’s infrastructure.

Here’s the problem: GitHub was built for humans. The PR diff view assumes eyeballs scanning changes. Review threads assume typing speed. Rate limits assume the request volume one developer generates in a day. Every design decision in that platform encodes an assumption about human pace.

Run ten agents in parallel. Then a hundred. Every one of those assumptions breaks. Agents hammer the repository dozens of times per second, spawn branches by the score, and open PRs on a clock measured in minutes. You’re pushing machine traffic through human-scale plumbing.

From Cursor’s seat, that means someone else’s servers set the ceiling on its product. Companies do not tolerate that arrangement for long.

The Timing of That Hacker News Thread

The HN post itself was unglamorous. Slower page loads. Intermittent failures. A general sense that things aren’t as solid as they used to be.

Threads like this surface periodically for any large service. Outages happen. What makes this one worth noting is context.

Microsoft acquired GitHub eight years ago, in 2018. Since then, and especially over the last three, the company has reorganized around Copilot. That’s a rational bet — but it moves the center of gravity from repository hosting to AI products, and organizations reveal their priorities through where they put their best people.

What developers are worried about isn’t downtime. It’s whether the fundamentals still get attention. Code hosting is a trust business. Features are nice; the actual product is the confidence that the thing will be there and working every time you push. Once that confidence cracks, evaluating alternatives stops feeling paranoid and starts feeling prudent.

The thread also carried the usual chatter about senior infrastructure people leaving. Rumors like that are unverifiable and often wrong. But the fact that a community takes them seriously is itself information. Nobody spreads decline narratives about a company they believe is solid.

Switching Costs Are the Real Moat

Now the counterargument, because it’s strong.

Git is distributed by design. Clone the repo, push it somewhere else, done. The technical migration takes minutes. This has always been true, and it has never mattered.

What holds you in place is everything wrapped around the repository. Issue history. PR discussions where architectural decisions got made. CI configuration. Deploy pipelines. Third-party integrations. Org-level permission structures. For open source, add stars, contributor networks, and the discovery graph that makes your project findable at all.

Then there’s the part nobody designed on purpose: a GitHub profile URL is a line item on developer résumés. It’s the link recruiters click. Fifteen years of commit history isn’t a backup you can restore elsewhere.

GitHub’s moat isn’t technical. It’s social infrastructure — and that’s the harder kind to breach. Cursor almost certainly knows this, which tells you something about what Origin is actually for.

The Bet Isn’t a Frontal Assault

The plausible read: Cursor isn’t trying to make anyone abandon GitHub. It’s trying to own the workspace where agents do their work.

Picture what AI-generated code actually looks like in progress. Dozens of speculative branches. Failed approaches. Reverted commits. Three attempts at the same refactor before one sticks. None of that belongs in the canonical repository. No human teammate needs to see it.

So the natural architecture is: messy intermediate work happens inside Cursor, and only clean, reviewed output gets pushed to GitHub. Nobody has to migrate anything. Nobody changes their profile URL. Resistance approaches zero, because the ask is zero.

But developers end up spending most of their working hours inside Cursor’s environment, with GitHub gradually reduced to a place where finished artifacts get archived. That’s a much better position to attack from than a head-on migration pitch, and it’s almost certainly the actual plan.

The risk is still real. Repository hosting burns money — storage, bandwidth, and above all the operational discipline never to lose a byte of customer data. Building a great editor and running always-on infrastructure are different muscles entirely, and source code is among the most sensitive assets any company owns. One serious data-loss incident would end this experiment permanently.

The Fight Is Over Where Developers Spend Their Day

Step back and this isn’t Cursor versus GitHub. It’s a question about where the center of the toolchain lands.

For the past decade, the winners in developer tools were whoever occupied the workflow’s center. GitHub won not because it stored code well — plenty of systems store code well — but because code review and collaboration happened there. Storage was the excuse. Collaboration was the product.

Collaboration is now shifting from human-to-human toward human-to-agent and agent-to-agent. When the reviewer is an AI and the commit author is an AI, the argument for staging that work on a human-optimized platform gets noticeably weaker.

GitHub understands this. Betting the company on Copilot is the response. But if that pivot leaves an impression that the core service is drifting, it hands over exactly the ground it was meant to defend. That’s why the timing of the HN thread stings.

The Takeaway

Nobody needs to migrate a repository tomorrow. Fifteen years of accumulated social infrastructure doesn’t evaporate because a well-funded competitor shipped a product.

But over the next year or two, watch which screen developers actually live in. That’s the metric that matters, and it’s the one that moves first.

If most of the entities reading and modifying your code are AI, one question follows: should that code sit where humans find it comfortable, or where machines do. Cursor picked an answer.