← All posts

SpaceX Is Buying Cursor. Here's How to De-Risk Your AI Coding Workflow.

SpaceX is buying Cursor. The Hacker News thread hit 806 points, Reuters ran a security story the same day, and Google autocomplete has gone unusually dense — "cursor alternative open source," "cursor alternative for local llm," "cursor alternative free open source," "cursor alternative 2026." People are searching for the exit ramp in real time.

Most of the coverage will be about the deal: the valuation, what Elon wants with an AI code editor, whether this is about Starlink tooling or something bigger. That's interesting, but it's not your problem.

Your problem is simpler and more urgent. You use Cursor to write code. Your code — and the context Cursor sends to its models — is now going to be owned by a company with a very different set of incentives than the one you signed up with. And you want to know: what breaks, what are my open-source / self-hosted alternatives, and how do I de-risk my workflow?

That's the post I'm writing. I've spent the last year writing about running local LLMs and self-hosted AI coding — the self-hosted AI coding assistants guide, the Cursor Origin vs self-hosted Git framework, the practical Mac mini guide, and the quantization deep-dive. This acquisition is the first real reason to treat Cursor the way I've been telling you to treat every other hosted dependency: as something you can walk away from.

Here's what actually changes, what doesn't, and the concrete steps to take this week.

First, the Part Everyone Gets Wrong

Let me save you the panic spiral. Cursor is not going to disappear tomorrow.

SpaceX isn't buying Cursor to shut it down. It's buying the team, the technology, and the distribution — the fact that millions of developers already have Cursor in their muscle memory. Killing the product would be like buying a car and setting it on fire.

The realistic risk is not "Cursor vanishes." It's "Cursor's incentives change." And that's a much harder thing to plan for, because it doesn't happen with a bang. It happens with a series of small, boring, easy-to-miss changes:

  • A shift in the privacy policy or ToS around what code/context gets used for training.
  • A change in pricing, or a push toward enterprise/team plans that deprioritize the individual developer.
  • A change in what models Cursor routes to, or where your code gets processed.
  • A slow migration of the "good" features behind a SpaceX-adjacent account or infrastructure.

The self-hoster's job isn't to predict which of these happens. It's to make sure that none of them can take your workflow down. That's what the rest of this post is about.

What Actually Breaks (and What Doesn't)

Let's be precise about your dependency. When you use Cursor, here's what's actually happening:

  1. Cursor runs as an editor on your machine (this part is local).
  2. Your code and context get sent to Cursor's backend (or directly to model providers) for completion and chat.
  3. The model returns a response, which Cursor renders in your editor.

The key insight: your editor is local, but your AI is not. The thing you're dependent on isn't the text editor — it's the pipeline that sends your code to a model and gets a response back. That pipeline is the part that changes when ownership changes.

So here's the honest breakdown of what breaks if Cursor changes under SpaceX:

Doesn't break:

  • Your existing code. It's on your disk. It's yours.
  • Your git history. Cursor doesn't own your repos (unless you're on Cursor Origin — see below).
  • Your ability to edit code. A text editor is a text editor.

Might break:

  • The AI features — completions, chat, agent mode — if pricing, models, or routing change.
  • The privacy posture — if the ToS changes around what gets used for training.
  • Cursor Origin, if you adopted it — that's a hosted dependency, and it's the most exposed part of your setup.

Breaks if SpaceX gets aggressive:

  • The "just use Cursor" reflex that every tutorial and onboarding doc relies on.
  • Any workflow that assumes Cursor's specific model routing and context handling will stay the same forever.

The pattern is clear: your risk is concentrated in the AI pipeline, not the editor. So de-risking means making that pipeline redundant — and the cleanest way to do that is to point your editor at models you control.

The Open-Source Alternatives (What Actually Replaces Cursor)

Here's the part you came for. These are the open-source tools that replace Cursor's AI coding workflow, ranked roughly by how close they get to a drop-in replacement.

Continue — the closest drop-in

Continue is a VS Code (and JetBrains) extension that gives you Copilot/Cursor-style inline autocomplete and a chat panel. The killer feature: it's backend-agnostic. You can point it at Ollama, a self-hosted model, or any OpenAI-compatible API. It's the single best answer to "I want Cursor's UX but I want to own the model."

{
  "models": [
    {
      "title": "Qwen Coder 14B",
      "model": "qwen2.5-coder:14b",
      "provider": "ollama"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen Coder 14B",
    "model": "qwen2.5-coder:14b",
    "provider": "ollama"
  }
}

I covered Continue in depth in the self-hosted AI coding assistants guide — it's still my default recommendation.

Aider — the terminal pair-programmer

Aider is a terminal-based tool that integrates with Git. You describe a change in natural language, and Aider makes it as a commit. It's not an editor — it's a pair programmer that works alongside whatever editor you already use. It supports Ollama, OpenAI, Anthropic, and any OpenAI-compatible endpoint.

pip install aider-chat
aider --model ollama/qwen2.5-coder:14b

Aider is the answer for people who don't want to switch editors at all — you keep VS Code (or Neovim, or whatever), and Aider handles the AI.

Cline — the agentic VS Code extension

Cline is a VS Code extension that's closer to Cursor's agent mode than its autocomplete. It can read and edit multiple files, run commands, and work through a task end-to-end. It supports any OpenAI-compatible API, which means Ollama, LM Studio, or a self-hosted endpoint. If you use Cursor's agent features heavily, Cline is the closest open-source equivalent.

OpenHands — the autonomous agent platform

OpenHands (formerly OpenDevin) is a full autonomous coding agent — it runs in a sandbox, plans, edits, runs tests, and iterates. It's heavier than the others and more of a "give it a task and walk away" tool than an inline assistant, but it's the most complete open-source answer to the "AI does the whole task" workflow. It runs in Docker and can point at any model backend.

The rest of the field

  • Tabby — self-hosted, team-oriented, with a web UI and its own model serving.
  • Twinny — privacy-first VS Code extension, minimal telemetry, Ollama/LM Studio support.
  • CodeGPT — beginner-friendly VS Code extension with Ollama support.
  • Zed — a full editor (not an extension) with built-in AI that can point at local models.

The through-line: every one of these lets you choose the model backend. That's the whole point. Cursor's lock-in isn't the editor — it's the fact that the AI pipeline is welded to Cursor's servers. These tools un-weld it.

The Self-Hosted / Local LLM Layer

The editor is only half the story. The other half is where the model runs. If you swap Cursor for Continue but still point Continue at a hosted API, you've traded one dependency for another. The real de-risk is running the model yourself.

Here's the stack I've been writing about all year, and it slots in perfectly here:

  1. Ollama — the de facto standard for serving local models. brew install ollama, then ollama pull qwen2.5-coder:14b.
  2. A coding model — Qwen2.5 Coder 14B is the sweet spot for most hardware; 32B if you have 24GB+ RAM. See the quantization deep-dive for squeezing more out of less.
  3. A capable box — a Mac mini (M4/M6) or a Proxmox LXC with a GPU. I've written the hardware guide and the M6 upgrade math.

The honest caveat, which I've said before and will say again: local models cap out below the frontier cloud models. For routine coding — boilerplate, tests, refactoring, docs, explaining unfamiliar code — a well-configured local setup is genuinely competitive. For the hardest reasoning tasks, a frontier cloud model still wins. The pragmatic answer is a hybrid: local for the daily 80%, a cloud API (via OpenRouter or similar) for the hard 20%, and you control the routing.

That hybrid is the key insight. You don't have to go fully local to de-risk. You just have to make sure that no single vendor owns your entire AI pipeline. Cursor owns the editor and the model routing and (if you use Origin) the git hosting. That's three dependencies in one. The de-risk is to split them back apart.

The De-Risking Playbook

Here's what I'd actually do, in order of effort. Most of it you can knock out in an afternoon.

1. Inventory What You Actually Depend On

Before you migrate anything, know what you have. Ask yourself:

  • Do I use Cursor's autocomplete, chat, agent mode, or all three?
  • Am I on Cursor Origin, or do I host my own git (GitHub/Gitea/Forgejo)?
  • What models am I actually relying on, and can I get them elsewhere?
  • What's in my .cursor config and my Cursor settings that I'd need to reproduce?

The features that matter most are the ones you can't trivially reproduce elsewhere. Agent mode and Origin are the highest-risk; plain autocomplete is the lowest.

2. Export Your Config and Settings

Cursor stores its settings and rules in .cursor/ (project-level) and your user settings. Copy them out now, while everything still works:

# Project-level Cursor rules
cp -r .cursor ~/cursor-backup/ 2>/dev/null

# Your Cursor user settings (macOS)
cp ~/Library/Application\ Support/Cursor/User/settings.json ~/cursor-backup/ 2>/dev/null

Your .cursorrules (or .cursor/rules) files are the most valuable thing here — they encode your project conventions and are directly portable to Continue, Cline, and Aider.

3. Stand Up a Parallel Setup (Don't Rip and Replace)

The worst way to de-risk is to delete Cursor on a Friday and hope the alternative works on Monday. Instead, run them in parallel for a week:

  • Install Continue (or Cline) in VS Code alongside Cursor.
  • Point it at Ollama (or your chosen backend).
  • Use the alternative for a few real tasks each day.
  • Only switch fully once you're confident the alternative covers your actual workflow.

This is the same "shadow mode" approach I recommend for any migration. You don't cut over until the new thing has proven itself on real work.

4. Split Your Dependencies

The single highest-value move is to make sure no one vendor owns everything:

  • Editor → VS Code, Zed, or Neovim (all open, all portable).
  • AI backend → Ollama (local) + an OpenAI-compatible cloud API for the hard tasks, routed by you.
  • Git → GitHub, or better, self-hosted Gitea/Forgejo.

If you're on Cursor Origin, migrating your git off it is the most urgent step — that's a hosted dependency with no clean exit, and it's the part most exposed to an ownership change. I wrote the decision framework for exactly this.

5. Watch the Terms, Not the Headlines

The headlines will scream "SpaceX owns Cursor!" for a week and then move on. The thing that actually matters is quieter: the ToS, the privacy policy, and the pricing. Set a reminder to check these in 30, 90, and 180 days:

  • Cursor's Terms of Service and Privacy Policy — watch for changes to training, data use, or routing.
  • The pricing page — watch for plan changes that deprioritize individual developers.
  • Any announcement about model routing or infrastructure changes.

You don't need to obsess. You need to notice when the ground shifts, so you can act before it's a problem.

The One Thing to Do This Week

If you do nothing else, do this: stand up a parallel open-source setup and export your Cursor config.

That's it. Not a full migration. Not a panic switch. Just:

  1. Install Continue (or Cline) in VS Code.
  2. Point it at Ollama with a coding model.
  3. Copy your .cursorrules into it.
  4. Use it for a few real tasks this week.

That's an afternoon of work, and it converts "what if Cursor changes under SpaceX" from an anxiety into a non-event. You'll have a working, open-source, self-hostable alternative already running — and if Cursor stays great, you've lost nothing. If it doesn't, you've already got your exit ramp paved.

The broader lesson is the same one I keep coming back to in this series: the self-hoster's superpower is not predicting the future. It's making the future irrelevant. You can't know what SpaceX will do with Cursor. But you can make sure that whatever they do, your editor keeps working, your models keep running, and your code stays yours.

That's the whole game. Everything else is just a headline.


Want to go deeper on self-hosted AI coding? Start with the self-hosted AI coding assistants guide, then check out the Cursor Origin vs self-hosted Git framework, the practical Mac mini guide, and the quantization deep-dive.