I switched from Cursor to Claude Code. Here’s what surprised me.

I’ve spent the better part of a year reaching for Cursor when I needed to write code or debug something in my homelab. It lives in my editor, it’s fast, and I’ve paid for it once. Then I started using Claude Code from the terminal, and now I’m finding myself reaching for it in situations where Cursor used to feel like the obvious choice. This isn’t a clean story of one being better than the other. It’s more complicated than that.

Why I was happy with Cursor

Cursor felt like VS Code with superpowers glued directly into the place where I already spent eight hours a day anyway. I could highlight a block of Python, ask it to rewrite the error handling, and see the change inline. The model was solid. The editing experience was frictionless. I paid the one-time fee and didn’t think about it again.

For homelab work—which is a lot of gluing scripts together, testing Docker compose files, writing small utilities—this worked well. I’d open a project, ask Cursor to help me understand the structure, and it would generate reasonable starting points for new features or fixes.

The moment I reached for the terminal instead

It started with a networking script that had gotten out of hand. A bash file with about 400 lines of logic, multiple functions, some error handling I wasn’t confident in, and a test suite that was starting to diverge from what the script actually did. I opened it in Cursor, highlighted everything, and asked it to refactor. The problem was immediate: it suggested changes to small sections, but couldn’t really hold the whole thing in its head. I’d accept a refactor, run the tests, find that it broke something three files over, and have to ask again.

I tried Claude Code on a whim. Different experience entirely.

Instead of working in the editor, you give it context about your whole project at once. You tell it what you want to fix or build. It reads your git history, your actual test files, your configs. Then it makes changes across multiple files if it needs to, runs your test suite itself, and shows you what it did.

claude-code fix-networking-script 
  --context "./scripts/network.sh ./tests/ docker-compose.yml" 
  --task "refactor network.sh to separate IP validation into a standalone function, ensure tests still pass"

What happened next was the surprise: it worked. Not perfectly—it reorganized some things I would have done differently—but it tested itself, found an issue with variable scoping I’d missed, and left me with something genuinely better.

The cost of leaving the editor

Here’s the friction I didn’t expect: I miss the immediacy of Cursor. Sitting in the editor, making a small change, watching the autocomplete flow—there’s a rhythm to that. Claude Code is powerful but it’s a different motion. You context-switch to the terminal. You wait for it to read your codebase. You get back a set of changes that might be larger than you expected. Sometimes that’s good. Sometimes you wanted to just ask a quick question about a single function.

I’ve also realized I’m more dependent on proper git history and clean test setups now. Cursor is forgiving about working with messy code. Claude Code expects you to have structure it can reason about. One of my homelab projects is a collection of ad-hoc Python scripts. Cursor doesn’t care. Claude Code reads it, understands it’s messy, and sometimes just… suggests I reorganize before it helps. Which is fair feedback, but it’s not what I wanted when I just needed a quick fix at 11 PM.

And there’s the self-hosting question I keep circling back to. Cursor runs locally. Claude Code talks to Anthropic’s API. If you’re running things in a homelab because you want control, that matters to you. It matters to me, at least a little, though I’m probably being romantic about it.

What I actually use each one for now

I haven’t replaced Cursor with Claude Code. I’ve added Claude Code for specific kinds of work. When I’m refactoring something real—something with tests, a clear structure, a scope I can articulate—Claude Code is the right tool. It sees the whole shape of the problem. When I’m exploring, sketching, asking small questions, Cursor stays open. The difference is real and I notice it every time I reach for the wrong one.

The honest part: I thought I’d move entirely over to Claude Code because it seemed more powerful. Turns out it’s more powerful for a subset of things, not for everything. The tools have different shapes, and the shape matters as much as the capability.

If you’re reading this thinking about making a switch, don’t expect a narrative where one clearly wins. What you’ll probably find is that you use both, and you get better at knowing which situation each one fits. That’s less satisfying than a strong recommendation, but it’s true in ways that recommendations usually aren’t.

Explore Claude Code in our AI Homelab Toolkit.