Cursor to VS Code + Claude, Six Months Later: The Honest Before and After

I wrote about leaving Cursor for stock VS Code and Claude a while back, and that piece keeps drawing traffic and email. Most of the email asks the same thing: did the switch actually hold, or was it a honeymoon post? So here is the return trip, with more depth and fewer manifestos. This is what the two setups feel like to live in, where each one wins, and who I think should stay put.

Being fair to Cursor first

Cursor is a good product. I want to say that plainly before I explain why I left, because the internet loves a clean villain and Cursor is not one.

The inline experience is genuinely excellent. Tab completion that predicts your next several edits, not just the next token, is a real advance and it still beats anything I get in stock VS Code. The multi-file edit flow is coherent. The team ships fast and clearly uses their own tool. If your entire mental model of AI-assisted coding is "the editor suggests, I accept," Cursor is the most refined version of that idea available.

So the reasons I left are not "Cursor is bad." They are structural, and they added up.

You live in a fork. Cursor is a fork of VS Code, and a fork trails upstream by definition. When VS Code ships a feature or a fix, you wait for Cursor to pull it forward, and sometimes it arrives changed or delayed. Most days you do not notice. The days you do notice are annoying out of proportion, because you know the fix already exists somewhere you no longer live.

You are locked to their pricing and their routing. Model access and request pricing move on Cursor's schedule, and the tool decides a lot about which model handles what. That is fine until you want a different answer than the one their routing gives you. You are renting a curated experience, and curation is exactly the thing that chafes once you have opinions.

Settings and extension drift is a real tax. Running a fork means your extension compatibility, your settings sync, and your muscle memory all sit slightly off from the mainline everyone else documents against. Small, constant friction. A tax you pay in attention.

None of these is fatal. Together they were enough.

What replaced it

Stock VS Code, updated from upstream like everyone else, plus Claude Code, Anthropic's agentic CLI that also wires into the editor. That pairing is the whole story, and the interesting part is that it changed where the AI lives in my workflow.

Cursor's center of gravity is the editor. The agent reaches out from inside your file, suggesting and rewriting inline. Claude Code's center of gravity is the terminal. You hand it a task, it reads the repo, runs commands, edits across files, and reports back. One is inline-native. The other is terminal-native. That difference is not cosmetic: it reorganizes how you think about the work.

With the inline model I stayed at the keystroke level, guiding the tool edit by edit. With the terminal-native agent I moved up an altitude. I describe an outcome ("wire this route through the ad URL builder and add the compliance rel attribute"), and I review a result rather than steering every edit. I still drop into the file for the delicate parts. But the default posture changed from driving to delegating, and once the muscle memory adjusted I did not want to go back.

The setup that actually matters

This is not an install listicle. Most of the extensions you already run in VS Code just work, because it is VS Code. Here is what earns its place.

Start with the language and framework extensions you would install anyway: the official language servers for whatever you write, ESLint and Prettier wired to format on save, GitLens for history you can actually read. None of this is exotic. That is the point. You are back on the mainline, so the entire ecosystem's documentation applies to you again without an asterisk.

Install Claude Code and connect it to the workspace so the agent and the editor share context. Keep it running in the integrated terminal rather than a separate window, because the value is having the agent one pane away from the code it is editing while you watch the diffs land.

The settings that matter are boring and worth doing. Turn on format-on-save and settings sync so a fresh machine is five minutes from ready. Keep an eye on which built-in AI suggestions you have enabled so they do not fight the agent. And write a project instructions file that tells the agent your conventions, because a terminal-native agent is only as good as the context you give it up front. That file is the single highest-leverage thing in this whole setup. It is where "delegate an outcome" becomes reliable instead of a gamble.

On models: the Claude 5 family and the Opus line cover the range from fast edits to heavier reasoning, and the honest advice is to reach for a smaller, faster model for routine work and a stronger one when a task actually needs the horsepower. The point of owning your setup is that this is your call, not a routing decision made for you.

The before and after, without the spin

What got better is ownership. I update on the same cadence as upstream VS Code. I choose the model. My extensions and settings are mainline, so drift stopped being a background cost. And the terminal-native agent moved me up an altitude on the kind of multi-file, run-the-tests-and-fix-it work that used to be tedious to steer inline.

What got worse, or at least took adjustment, is honest to report. I missed Cursor's inline tab completion immediately. That next-edit prediction is the best in the business and stock VS Code does not match it. My hands had built up real muscle memory around accepting those suggestions, and for a short stretch I kept reaching for a completion that was not there. The muscle memory came back the other way within a day or two, but it was a real cost while it lasted. If your work is dominated by tight inline editing rather than delegated tasks, you will feel that gap more than I did.

So this is a tradeoff, not an upgrade in every direction. I traded the best inline feel for ownership and a terminal-native agent that fits how I actually work now. For me that trade is clearly worth it. It will not be for everyone.

Who should switch, who should stay

Switch if you have opinions about your models and your updates and you resent renting those decisions. Switch if your work has moved toward delegated, multi-file, agentic tasks where you review outcomes more than you steer keystrokes. Switch if being on mainline VS Code, with the whole ecosystem documented for exactly your setup, sounds like relief rather than a lateral move.

Stay on Cursor if the inline experience is the heart of how you code and that next-edit prediction is load-bearing for you. Stay if a curated, decided-for-you setup is a feature and not a cage, because for a lot of people it genuinely is. Stay if you have no interest in living in a terminal alongside your editor.

I moved up an altitude and stopped fighting my tools, and the setup held past the honeymoon. That is the real report. Your work is not my work, so weigh it against how you actually spend your keystrokes, not against how the demo looks.