Cursor Is the Most Correct Tool. So Why Am I Not Using It?

I think Cursor figured out where this whole job is going. I’m also not using it right now. Let me try to explain that.

The Most Correct Tool in the Room

It’s open season on Cursor right now. The pricing saga alone could fill a postmortem: the Pro plan everyone treated as effectively unlimited got swapped from request limits to compute credits, effective cost on heavy agent workflows jumped something like twenty-fold, the refunds went out, and people started leaving for Windsurf and Claude Code. Then Cursor 3 landed - rebuilt from scratch under the codename Glass - and did the one thing nobody expected from the company that won by making the best editor on the market. It demoted the editor. The New Stack called it plainly: the IDE is now a fallback, not the default.

And here’s the part that gets me funny looks. I think it’s the most correct tool in the category. The Medium headline that kicked off the backlash - “Cursor 3 Is Not an IDE Update. It’s a Bet That You’ll Manage Agents, Not Write Code” - was written as an accusation. I read it as a correct thesis. Typing code is commoditized now. The work is sliding from writing keystrokes to overseeing the agents that write them, and Cursor pointed the whole company at that before its competitors were done arguing about autocomplete. They saw it first, which is the hardest kind of right to be. I’m rooting for them.

Which leaves a paradox on the table. The most accurate read of the future belongs to the company everyone’s piling on - and I’ve quietly stepped away too. If the vision is right, and I think it is, then my reason for not using it can’t be the vision. So what is it?

So Why Am I Not Switching?

Most people leaving Cursor are leaving for reasons a spreadsheet could fix. Burned on a bill. Annoyed that the editor got shoved into a side panel. Real complaints, all solvable in a quarter with clearer pricing and a layout toggle.

Mine aren’t on that list. I didn’t leave over price, and I didn’t leave over the layout. I’m the sympathetic case - I agree with the bet, I want the overseer future to show up, I’d happily pay whoever nails it. When the customer nodding along to your roadmap still reaches for something else, that tells you something a price cut won’t fix. Two things, actually. Neither of them is “the vision is wrong.”

Reason One: The Model Has Its Own Gravity

The first reason is simple. Opus 4.8 is just that good. The best model I can get my hands on, and once you’ve spent real time with a model that feels clearly smarter than the rest, going back feels like trading down a level. Interface polish doesn’t close that gap, because the gap is in the part that does the thinking.

We were sold the opposite story for years: the model is the swappable commodity, the tool is the moat. Pick your editor, plug in whatever model you like, let the ergonomics win your loyalty. That held up while the models were close enough that the difference was rounding error. It comes apart the moment one pulls ahead, because then the model is the whole reason the output is any good.

I refer to it model gravity. The best model bends everything toward itself, and the pull lives in the small stuff you stop noticing you asked for. Opus 4.8 finds the edge cases on its own - the empty state, the race condition I’d have forgotten - without me writing “handle the edges” anywhere. It builds better UIs by default, the kind I’d otherwise have to art-direct line by line. It writes code that already matches our paradigms instead of the generic textbook version I’d have to rewrite. The roadmap doesn’t write the code. The model writes the code, and right now the good one isn’t Cursor’s.

I’ve said publicly that the model isn’t the thing that matters, and I still believe it - long term these all converge and this entire reason evaporates. Every one of those saves is really a prompting problem. I could write the context that makes a weaker (and more affordable!) model find the same edges and match the same paradigms. I just don’t, because Opus is far enough ahead that I don’t have to, and the pricing is fine, so the effort never clears the bar. That’s the honest shape of model gravity today: the best model is far enough ahead that paying for it beats doing the prompting work to live without it. Nothing permanent about that. If/when the Anthropic pricing economics stop working for me, I’ll upgrade our prompts and switch to a Qwen 3.7 Plus or MiniMax 3 or Composer 2.5 or what-have-you.

Reason Two: A Promising Model That Doesn’t Think Like One Yet

Now the fair part, because the easy thing here is a cheap shot and I don’t want to take it. Cursor builds its own model, Composer, and Composer 2.5 has real potential - I’m bullish on it. It’s fast, it’s tuned for exactly the workflows Cursor cares about, and owning your model end to end beats renting one. Building it is the right long-term call.

But potential isn’t readiness. In my daily use, Composer 2.5 didn’t behave like an agent yet. The tell: handed an ambiguous task, it kept trying to write deterministic code - script the procedure, run the procedure - instead of reasoning the way a good agent does, sitting in the uncertainty, trying things, backing out of dead ends, noticing when the spec itself is wrong. Add a pile of small quirks that each cost you thirty seconds and together cost you flow, and you get something good at generating code but not yet good at being an agent. I had to ask it multiple times to act like an agent, and it kept refusing and trying to write shell scripts on things that could not be done deterministically.

That sounds academic until you remember what Cursor is selling. The whole bet assumes the thing you’re managing is autonomous enough to be worth managing. A model that defaults to deterministic codegen is quietly fighting its own company’s strategy - the cockpit’s built for an autonomous aircraft, but the engine still wants to be driven like a car. And fast, fluent codegen is mostly a solved problem; reliable agentic reasoning is the actual frontier, the thing the big labs are throwing everything at. Cursor’s chasing it while also building an editor, a cloud platform, a pricing model, and a whole interface paradigm. The model is the priority that least tolerates being one of five. Six weeks from now this paragraph might be wrong. Today it isn’t.

The Pattern: Model and Loop Beat Vision

Put the two together and they rhyme. The best model isn’t theirs. The model they own doesn’t think like an agent yet. Strip the specifics and it’s one complaint: the value lives in the model underneath and the review loop on top of it, and the vision of managing a fleet sits in neither place. The vision is the one thing Cursor got dead right, and it turned out to matter least.

That should change what everyone’s competing over, and mostly it hasn’t. The whole field is racing to build dispatch - spin up a sandbox, clone the repo, run the agent, open the PR, fan out across a swarm. Dispatch is a commodity. The most honest line I read all year, in a thread full of people trying to define “async agents,” was that “background job” is the more honest framing. That’s all dispatch is. You don’t get a moat out of a job queue.

The line from that same thread that actually matters: “the supervision protocol is the product, not the async dispatch.” That’s the whole game. The unsolved, defensible layer is the loop where a human reviews and corrects what the agent did - the last real bottleneck, because output scaled to thousands of lines an hour and human reading speed didn’t. Whoever makes that loop trustworthy and fast owns the workflow. And that loop wants a smart model under it - one that can summarize its own diff and flag where it’s unsure - which favors whoever already has the best model. Watch where the people leaving Cursor actually land: terminals, mostly. Claude Code, Codex. They’re winning on model and surface alone, and they haven’t even seriously built the review loop yet.

So I Roll My Own - Until I Change My Mind in Six Weeks

So I’m in a terminal, building my own version of Cursor. The best model wired to a supervision layer I built to fit exactly how I work - lean, mine, and good at the one job I need it to do. The vision Cursor’s selling is right; I just don’t want to rent it from them yet. I’d rather wire the best model to a review surface I control than rent a polished workbench whose model isn’t agentic yet and whose pricing I’ve stopped trusting. Call it a stopgap if you want - a placeholder for the product that doesn’t exist yet, best model behind a painless loop, that someone eventually ships. But it’s a real solve, and by my own argument it isn’t even the worse one: it already has the two things that matter, the model underneath and the loop on top, and skips the polish that turned out to matter least.

There’s a quiet condition under all of this, though: building my own is cheap because I’m the one running it. It works because there’s one set of hands on it, and the work to wire it up is small enough that it clears the bar. Scale that to a team and the math inverts - now the setup needs onboarding, shared infrastructure, and someone to keep it maintained, and those hours start to cost more than the model gap I’d be closing by renting. That’s the real flip for someone like me. Not the vision getting more right, but the day doing it myself stops being the easy win - when a team outgrows a one-person setup and I’d rather pay someone whose whole job is keeping the workbench standing. The other flip is the one I already named: the models converge, the gap evaporates, and the deciding factor becomes whoever wraps the best loop around them. Until one of those two days arrives, the homegrown version wins on the merits.

If there’s a lesson for Cursor here, it’s that being right about the future doesn’t help much if you don’t own the model under it - and that you bring your users along instead of leaving them in the present. The people who loved Cursor signed up for the fastest editor on earth and got asked to become fleet managers nearly overnight. Maybe the overseer paradigm deserved its own product line: a new thing for the people ready for it, sitting next to the editor everyone already paid for. You can be early and still get ahead of your own users, and trust doesn’t come back with a changelog.

Here’s the honest part, and I think it proves the rest. This whole verdict expires in about six weeks. I’m not loyal to Claude Code. I’m loyal to whatever model is best this month, and the title keeps changing hands. The day a better one drops - maybe Composer 3 finally thinks like an agent and becomes my new go-to - I’ll throw out everything I just said and follow it. And if a single release can flip my entire setup, model and terminal and workflow and all of it, then the model is the product and everything above it is rented. The vision’s rented. My harness is rented from whatever model it wraps this week. So the only thing worth getting good at is switching: keep the part that’s actually yours - your judgment, your taste for what “good” looks like - light enough to carry to whatever wins next.

To me, Cursor has described the future more clearly than anyone. I can’t wait to find out who executes on it best.