I love Cursor but I’ve recently switched to Claude Code (CLI) and I can’t see myself moving back anytime soon.

What’s odd is that I can’t point to a single killer feature. I’ve seen no strong evidence that Opus 4.5 performs better in Claude Code than in Cursor and everything I do in Claude Code is theoretically just as easy to do in Cursor.

So why do I prefer using Claude Code and why do I feel more productive with it?

I think the answer is mostly psychological. It’s about incentives and workflow shape, not raw capability.

The annoying thing about AI right now is that the best way to work keeps changing. Most engineers don’t want to re-learn their workflow every few weeks, so there’s always a lag between what the tools can do and what we think they can do. The product that quietly pushes you into the new right way to work gets credit for “discovering” it, even if the underlying capability was there all along.

Friction-as-a-feature

AI agents still mess up. And when they do, Cursor makes it almost too easy to perform a “manual override”; jump into the code, fix the issue yourself and move on.

That feels productive. It’s also how you end up half-using the agent.

Agents are now good enough that the fastest path usually isn’t “fix it yourself”, instead it’s telling the agent what went wrong and letting it correct itself.

Think about a boring but real example. You ask for a refactor across 20 files, it gets 19 right but misses one instance. Cursor makes it trivial to just fix the last one and carry on.

But if you do that you don’t get the agent to finish the job properly and you train yourself into a habit of stepping in early.

Cursor is an AI collaboration tool in an era of AI delegation

Most of us do this because it’s predictable. When there’s uncertainty, we default to the known path to completion even if it’s slower.

Day-to-day software engineering is moving towards tech lead work. You direct agents, review their work and steer execution. Delegation is the core skill.

Claude Code helps because it makes manual override slightly less convenient. You can still open Cursor and fix it, but you’re not already sat in the editor. So you’re more likely to stay in the loop and make the agent finish the job.

That’s usually faster. More importantly, it builds the habit you actually want. The correction stays in context and if it matters you can turn it into a rule.

The power of unlimited

Here’s a quick test. Would you ask Cursor what the weather is like today?

There are dozens of things I ask ChatGPT each day that I would never put into Cursor because when using Cursor the cost is visible (even though it’s my employer paying for it).

Yes, in video games I save all my potions “for later” and finish the game with 800 potions.

With Claude Code the subscription is bottomless (within rate limits), which changes what I’m willing to delegate. I’ll ask it to do small, silly or excessive things I could easily do myself. (I’d happily ask Claude Code to tell me the weather.)

For instance, recently I had Claude Code not only implement a feature and open a PR but also read the Cursor BugBot comments on that PR, inspect failing CI and fix both for me.

Like I said at the start, Cursor can do all this too! The difference is that “unlimited” changes behaviour and my natural token anxiety drops away. I use the agent more aggressively, I explore more and I rely on it more.

Unlimited makes it feel wasteful not to delegate, so I don’t ration the agent.

What Cursor would need to win me back

This isn’t a “Cursor is doomed” post. Cursor is excellent! They have a brilliant team, they ship constantly and they’re very clearly paying attention.

The risk is that shipping becomes the strategy and the product turns into a feature factory. Cursor feels worse to me because the interaction pattern is different, not because Cursor has a missing feature. Claude Code feels better because it nudges me towards the right flow, rather than enabling my worst instincts.

The opportunity for Cursor is to help the user find the right default behaviour. Shape how people work, not just what the product can do.

Make delegation the path of least resistance

Here are a few things I think they should do to get back on top:

1) Build agent-first

Anything that can be done in the IDE should be easily achievable through natural language, not just as a gimmick but as a first-class interface.

In other words, give me the full power of Cursor’s IDE via the single agent textbox. Let the GUI be a view layer (diffs, context, navigation) but make the agent the control plane.

And parity matters beyond the IDE. The CLI should feel like a real sibling, not a side project with the same primitives, same workflows and same loop.

2) Keep the simplicity of a CLI, but use the GUI for leverage

Claude Code’s Terminal User Interface (TUI) is weirdly good at keeping me on the rails. I find it keeps me honest and I’m more likely to make the agent finish the job.

But a GUI lets you see more at a glance. Diffs, test output, what the agent did, where it touched, etc.

It’s notable that even the biggest Terminal fans are using their Terminal from within a GUI operating system. Find a way for users to get the best of both.

Cursor's built-in voice dictation is already a good "value-add" versus having to separately install a Wispr wrapper.

3) Offer a bottomless package

The other lever is purely psychological. Find a way to remove the feeling of a running meter.

Cursor has experimented with different pricing and usage models over time and it’s clear this is hard when you’re paying upstream model providers.

But the practical effect is simple; if users feel scarcity they ration. They stop delegating the small or uncertain tasks, even when the agent could do them better and faster.

This is why Cursor’s in-house models (Composer and whatever comes next) matter so much. If Cursor can offer a “bottomless (with rate limits)” tier on a strong first-party model it will change behaviour, turning discovery and mundane delegation into defaults rather than indulgences.

It’s becoming normal for teams to pay well north of $100 per engineer (especially if you’re using Opus 4.5) for tools that actually save time. If it’s the difference between “rationing” and “using it properly” it’s an easy sell. Cursor should lean into that reality, both in pricing and in product.

Bottom line

I want Cursor to win me back because it’s still a wonderful tool to use as a developer but in 2026 engineers can’t afford to micromanage now that the models are so capable.

Models will keep getting smarter and we’ll have to learn to delegate. The winning harness will be the one that helps users know when to intervene and when to get out of the model’s way.