Cursor 3
cursor.com540 points by adamfeldman 3 days ago
540 points by adamfeldman 3 days ago
I've been running Claude Code in my Cursor IDE for a while now via extension. I like the setup, and I direct Claude on one task at a time, while still having full access to my code (and nice completions via Cursor). I still spend time tweaking, etc. before committing. I have zero interest in these new "swarms of agents" they are trying to force on us from every direction. I can barely keep straight my code working on one feature at a time. AI has greatly helped me speed that up, but working serially has resulted in the best quality for me. I'll likely drop Cursor for good now and switch back to vanilla VsCode with CC.
I just wish Claude code would also offer fast inline auto complete. Sometimes I’ll just want to have a function definition or some boilerplate spelled out without waiting for the slow Claude response. Or actively switching models. ——- Maybe I can set up a shortcut for that?
Is there a significant difference between Claude Code in VSCode and Copilot in VSCode? I’ve been using Copilot with the Claude models (including Sonnet/Opus 4.6) and it seems to work spectacularly.
My subscription is only $10 a month, and it has unlimited inline suggestions. I just wonder if I’m missing anything.
I tried copilot for a bit in vscode as well with opus and felt something was off. Somehow as if copilots harness around it just wasn’t as good. But I can’t give solid prove.
Can't you use the official claude code vs plugin? AFAIK it uses the same binary as the cli in the background.
Yes and I do. My above point was just that I’d like to have fast inline auto complete.
> Is there a significant difference between Claude Code in VSCode and Copilot in VSCode? I’ve been using Copilot with the Claude models (including Sonnet/Opus 4.6) and it seems to work spectacularly.
Most models are limited to 200k context in GitHub Copilot. The Claude models are now 1M context elsewhere.
The $10/month plan offers a quite limited number of tokens for advanced models. And if you are not careful and set the model to Auto it will quickly deplete them.
Not a real solution but you could try using AquaVoice for dictation. It can gather screen context so you just say the function name out loud and it capitalizes and spells everything correctly. (Even hard cases!)
This. I have effectively used multiple agents to do large refactors. I have not used them for greenfield development. How are folks leveraging the agentic swarm, and how are you managing code quality and governance? Does anyone know of a site that highlights code, features, or products produced by this type of development?
I think it would be fantastic to have a reference site for significant, complex projects either developed or substantially extended primarily via agent(s). Every time I look at someone's incredible example of a workflow for handling big context projects, it ends up being a greenfield static microblog example with vague, arm-wavey assertions that it will definitely scale.
Same here. And just recently made the switch back to VS Code with CC
Also means you don't have to deal with Cursor's busted VS Code plugins due to licensing or forking drift (e.g. Python intellisence, etc)
Same setup here. Claude Code in the terminal, one task at a time. The swarm thing never clicked for me. When I'm building I need to hold the full context in my head, and watching the agent work is actually part of that. I catch things I missed in my own prompt while it's thinking. Parallelizing that would just mean reviewing code I have no mental model for. Serial is slower on paper but the code actually works at the end. I think these products are trying to capture no-coders, which is a recipe for disaster. They're trying to create architectures so people can say "build me X" and the agents perform magic end-to-end, output a hot pile of garbage. The actual value here is taking the finger-to-keyboard burden off the user and abstracting up to architect level. That means you still need to be able to review the goddamn code and offer an opinion on it to end up with something good. AI slop comes from people who don't have the skills and context to offer any valuable opinion or pushback to the AI. Vanilla CC is the best IMO.
This flow feels so slow after switching to Conductor and running X number of tasks in separate git workspaces concurrently
>I have zero interest in these new "swarms of agents"
I think you misunderstand "swarms of agents", based on what you say above. An agent swarm, in my understanding and checked via a google search, does not imply working on multiple features at one time.
It is working on one feature with multiple agents taking different roles on that task. Like maybe a python expert, a code simplifier, a UI/UX expert, a QA tester, and a devils advocate working together to implement a feature.
They’re not experts.
Sensitive but uninformed. Expert is a common AI concept, going back for decades. It wasn’t invented with LLM.
What do you mean, my prompts specifically ask for a phd level expert in every field?
\s
"Expertise" is a completely different beast from "knowledge".
Expecting to gain it from a model only through prompting is similar to expecting to become capable of something only because you bought a book on the topic.
> does not imply working on multiple features at one time.
How can multiple parallel agents some local and some in the cloud be working on a single task?
How can:
> All local and cloud agents appear in the sidebar, including the ones you kick off from mobile, web, desktop, Slack, GitHub, and Linear. (From the announcement, under “Run many agents in parallel”)
…be working on the same task?
Subagents are different, but the OP is not confused about what cursor is pushing, and it is not what you describe.
Same way a developer and designer can work on the same feature during the same week? Or two developers working on the same feature during the same week. They can have a common api contract and then one builds the frontend and the other works on the backend.
Subagents are isolated context windows, which means they cannot get polluted as easily with garbage from the main thread. You can have multiple of them running in parallel doing their own separate things in service of whatever your own “brain thread”… it’s handy because one might be exploring some aspect of what you are working on while another is looking at it from a different perspective.
I think the people doing multiple brain threads at once are doing that because the damn tools are so fucking slow. Give it little while and I’m sure these things will take significantly less time to generate tokens. So much so that brand new bottlenecks will open up…
They are confused in the word they use: the article on what Cursor is pushing does not, according to ^F, mention "swarm" at all. Since we have a word for multiple agents working on one task, it is probably best not to use that word if you are referring to multiple agents working on multiple tasks, right?
I bring it up not to be pedantic, but because if you think it implies multi-tasking and dismiss it, you are missing out on it's ability to help in single-tasking.
I think cursor doesn't make distinction between single or multiple logical tasks for swarm-like workloads. Subagents is the word they use for the swarm workers.
Fwiw when I select multiple models for a prompt it just feeds the same prompt to them in parallel (isolated worktrees), this isn't the same as the swarm pattern in 2.4+ (default no worktrees).
> I bring it up not to be pedantic
The OP is fundamentally expressing the opinion that single task threads are easier to keep track of.
Agree / disagree? Sure.
…but dipping into pedantry about terms (swarm, subagent, vine coding, agentic engineering) really doesn't add anything to the conversation does it?
You said:
> I think you misunderstand "swarms of agents", based on what you say above.
…but from reading the entire post I am pretty skeptical anyone was confused as to what they meant.
Wrong term? Don't care. If someone calls it a hallucination? Also don't care.
That cursor is focusing on “do stuff in parallel guys!”? Yeah, I care about that.
> it is probably best not to use that word if you are referring to multiple agents working on multiple tasks, right?
Not relevant to the thread. Also, I work with people who casually swap between using these exact words to mean both things.
I donnnt caarrrrre what people call it.
…when the meaning is obvious from the context, it doesnt matter.
Try Zed instead of VSC. Thank me later.
I did, but having the buttons on the bottom vs the side is a deal breaker for me, esp. since they are VERY tiny on my 4K screen. I can barely even get my mouse over them, and it seems they aren't movable to the left side like VSC? Am I missing something? Hard to believe this shipped, it is unusable for me.
You are falling behind if you're not pushing yourself to learn and get better orchestrating multiple agents.
Why is it that every legitimate concern or downside pointed out about AI is met with the same tired, low signal, rebuttal of FOMO.
It's become the "no u r" argument of the AI age... :/
Because the AI apologists cannot deal with the much studied and proven placebo effect of perceived increased productivity, so they have to try and make themselves feel better by claiming that others are lagging behind in a race no one else is really interesting in running.
A snake oil scheme if ever saw one.
> have zero interest in these new "swarms of agents" they are trying to force on us from every direction.
Good for you! Personally waiting for one agent to do something while I shove my thumb up my butt just waiting around for it to generate code that I'll have to fix anyway is peak opposite of flow state, so I've eagerly adopted agents (how much free will I had in that decision is for philosophers to decide) so there's just more going on so I don't get bored. (Cue the inevitable accusations of me astroturfing or that this was written by AI. Ima delve into that one and tell there was not. Not unless you count me having stonks in the US stock market as being paid off by Big AI.)
I have personally found that I cannot context switch between thinking deeply about two separate problems and workstreams without a significant cognitive context-switching cost. If it's context-switching between things that don't require super-deep thought, it's definitely doable, but I'm still way more mentally burnt-out after an hour or two of essentially speed-running review of small PRs from a bunch of different sources.
Curious to know more about your work:
Are your agents working on tangential problems? If so, how do you ensure you're still thinking at a sufficient level of depth and capacity about each problem each agent is working on?
Or are they working on different threads of the same problem? If so, how do you keep them from stepping on each other's toes? People mention git worktrees, but that doesn't solve the conflict problem for multiple agents touching the same areas of functionality (i.e. you just move the conflict problem to the PR merge stage)
This is a struggle I've also been having.
It's easier when I have 10 simple problems as a part of one larger initiative/project. Think like "we had these 10 minor bugs/tweaks we wanted to make after a demo review". I can keep that straight. A bunch of agents working in parallel makes me notably faster there though actually reviewing all the output is still the bottleneck.
It's basically impossible when I'm working on multiple separate tasks that each require a lot of mental context. Two separate projects/products my team owns, two really hard technical problems, etc. This has been true before and after AI - big mental context switches are really expensive and people can't multitask despite how good we are at convincing ourselves we can.
I expect a lot of folks experience here depends heavily on how much of their work is the former vs the later. I also expect that there's a lot of feeling busy while not actually moving much faster.
> I also expect that there's a lot of feeling busy while not actually moving much faster.
Hey don’t say that too loudly, you’ll spook people.
With less snark, this is absolutely true for a lot of the use I’m seeing. It’s notably faster if you’re doing greenfield from scratch work though.
Once I started agents and Claude code hid more and more of the changes it did from me it all went downhill..
Yes, also doesn't work for me. If the changes are simple, it is fine but if the changes are complex and there isn't a clear guideline then there is no AI that is good enough or even close to it. Gives you a few days of feeling productive and then weeks of trying to tidy up the mess.
Also, I have noticed, strangely, that Claude is noticeably less compliant than GPT. If you ask a question, it will answer and then try to immediately make changes (which may not be related). If you say something isn't working, it will challenge you and it was tested (it wasn't). For a company that is seems to focus so much on ethics, they have produced an LLM that displays a clear disregard for users (perhaps that isn't a surprise). Either way, it is a very bad model for "agent swarm" style coding. I have been through this extensively but it will write bad code that doesn't work in a subtle way, it will tell that it works and that the issues relate to the way you are using the program, and then it will do the same thing five minutes later.
The tooling in this area is very good. The problem is that the AI cannot be trusted to write complex code. Imo, the future is something like Cerbaras Code that offers a speed up for single-threaded work. In most cases, I am just being lazy...I know what I want to write, I don't need the AI to do it, and I am seeing that I am faster if I just single-thread it.
Only counterpoint to this is that swarms are good for long-running admin, housekeeping, etc. Nowhere near what has been promised but not terrible.
How does one work with a team of developers to solve larger problems? You break down the problems into digestible chunks and have each teammate tackle a stack of those tasks.
Its far closer to being a project manager than it is being a solo developer.
I tried swarms as well, but I came back to you as well. It’s not worth it even th e small worse description double-checking, fine-tuning is not worth the effort the worse code will cost me in the future. Also when I don’t know about it.
It's not that difficult. You get it to work on one deep problem, then another does more trivial bug fixes/optimizations, etc. Maybe in another you're architecting the next complex feature, another fixes tests, etc etc
> Are your agents working on tangential problems?
Unrelated problems simultaneously in the same git tree. Worktrees are unnecessary overhead if the area they're working in are disjoint. My Agents.md has instructions to commit early and often instead of one giant commit at the end, otherwise it wouldn't work.
> how do you ensure you're still thinking at a sufficient level of depth and capacity about each problem each agent is working on?
The context switching is hell and I have to force myself to dig deep into the MD file and understand things and not just rubber stamp the LLM output. It would be dishonest of me to say that I'm always 100% successful at that though.
I find it puzzling whenever someone claims to reach "flow" or "zen state" when using these tools. Reviewing and testing code, constantly switching contexts, juggling model contexts, coming up with prompt incantations to coax the model into the right direction, etc., is so mentally taxing and full of interruptions and micromanagement that it's practically impossible to achieve any sort of "flow" or "zen state".
This is in no way comparable to the "flow" state that programmers sometimes achieve, which is reached when the person has a clear mental model of the program, understands all relevant context and APIs, and is able to easily translate their thoughts and program requirements into functional code. The reason why interrupting someone in this state is so disruptive is because it can take quite a while to reach it again.
Working with LLMs is the complete opposite of this.
Thank you so much. These comments let me believe in my sanity in an over-hyped world.
I see how people think its more productive, but honestly I iterate on my code like 10-15 times before it goes into production, to make sure it logs the right things, it communicates intent clearly, the types are shared and defined where they should be. It’s stored in the right folder and so on.
Whilst the laziness to just pass it to CC is there I feel more productive writing it on my own, because I go in small iterations. Especially when I need to test stuff.
Let’s say I have to build an automated workflow and for step 1 alone I need to test error handling, max concurrency, set up idempotency, proper logging. Proper intent communication to my future self. Once I’m done I never have to worry about this specific code again (ok some error can be tricky to be fair), but often this function is just practically my thought and whenever i need it. This only works with good variable naming and also good spacing of a function. Nobody really talks about it, but if a very unimportant part takes a lot of space in a service it should be probably refactored into a smaller service.
The goal is to have a function that I probably never have to look again and if I have to do it answers me as fast as possible all the questions my future self would ask when he’s forgotten what decisions needed to be made or how the external parts are working. When it breaks I know what went wrong and when I run it in an orchestration I have the right amount of feedback.
As others I could go very long about that and I’m aware of the other side of the coin overengineering, but I just feel that having solid composable units is just actually enabling to later build features and functionality that might be moat.
Slow, flaky units aren’t less likely to become an asset..
And even if I let AI draft the initial flow, honestly the review will never be as good as the step by step stuff I built.
I have to say AI is great to improve you as a developer to double check you, to answer (broad questions), before it gets to detailed and you need to experiment or read docs. Helps to cover all the basics
So don't write slow flakey unit tests? Or better yet, have the AI make them not slow and not flakey? Of if you wanna be old school, figure out why they're flakey yourself and then fix it? If it's a time thing then fix that or if it's a database thing then mock the hell out of that and integration test, but at this point if your tests suck, you only have yourself to blame.
Sorry I don’t get your point and you didn’t seem to get mine.
I’m saying I would guess I’m faster building manually then to let AI write it, arguably it won’t even achieve the level I feel best with in the future aka the one having the best business impact to my project.
Also the way I semantically define unit tests is that they are instant and non-flaky as they are deterministic else it would be a service for me.
I switched to use LLMs exclusively since around March last year and I haven’t wrote a line of code directly since then.
I have followed the usual autocomplete > VS Code sidebar copilot > Cursor > Claude Code > some orchestrator of multiple Codex/Claude Codes.
I haven’t experienced the flow state once in this new world of LLMs. To be honest it’s been so long that I can’t even remember what it felt like.
"My flow state is better than yours"? Point is, I get engaged with the thing and lose track of time.
I can lose track of time watching a movie or playing a video game, but it's not what Mihály Csíkszentmihályi would call "flow state", but just immersion.
> Personally waiting for one agent to do something while I shove my thumb up my butt just waiting around for it to generate code that I'll have to fix anyway
I spend that time watching it think and then contemplating the problem further since often, as deep and elaborate as my prompts are, I've forgotten something. I suspect it might be different if you are building something like a CRUD app, but if you are building a very complicated piece of software, context switching to a new topic while it is working is pretty tough. It is pretty fast anyway and can write the amount of code I would normally write in half a day in like 15 minutes.
In my workflow, it's totally interactive: Give the LLM some instructions, wait very briefly, look at code diff #1, correct/fix it before approving it, look at code diff #2, correct/fix it before approving it, sometimes hitting ESC and stopping the show because the agent needs to be course corrected... It's an active fight. No way I'm going to just "pre-approve all" and walk away to get coffee. The LLMs are not ready for that yet.
I don't know how you'd manage a "swarm" of agents without pre-approving them all. When one has a diff, do you review it, and then another one comes in with an unrelated diff, and you context switch and approve that, then a third one comes in with a tool use it wants to do... That sounds absolutely exhausting.
It sounds like diff #2 depends on approval of diff #1? But with cursor it's a set of diffs that'll be retroactively approved or rejected one by one. So you can get coffee during the thinking and still have interactive checks. Swarm changes nothing about this, except affecting the thinking time.
For my work I’ve never found myself sitting around with nothing to do because there’s always so much review of the generated code that needs to be done
The only way I can imagine needing to run multiple agents in parallel for code gen is if I’m just not reviewing the output. I’ve done some throwaway projects where I can work like that, but I’ve reviewed so much LLM generated code that there is no way I’m going to be having LLMs generate code and just merge it with a quick review on projects that matter. I treat it like pair programming where my pair programmer doesn’t care when I throw away their work
Why is this comment so pale I cat read it? What’s the contrast on this is this accessible to anyone?
I’m guessing it was downvoted by the masses but at the same time I’d like the choice to be able to read it I’m not that into what the general public think about something.
I’m getting into downmaxxing at this point. I love that you have to earn being negative on this site. Give it to me.
Click on the timestamp link to go to the comment's own page where it will be rendered black instead of gray.
Except it isn't (anymore)? Timestamp + reader mode worked though.
Edit: it is black if logged in, gray if logged out. Weird.
Cursor has been my main AI tool for over a year now.
I've been trying to use Claude Code seriously for over a month, but every time I do it, I get the impression that it would take me less work to do with Cursor.
I'm on the enterprise plan, so it can get pricey. This is why I used to stick mostly to auto mode.
Now Composer 2 has taken over as my default model. It is not as intelligent as OpenAI's or Anthropic's flagship models, but I feel it has as good as or better intuition. With way better pricing. It can get stuck in more complex tasks though.
Being able to get in the loop, stop and instruct or change models makes all the difference. And that is why I've stayed in the editor mode until now. Let's see if 3.0 changes that.
I was a Cursor loyal until I was spending around $2k a week with premium models and my team had a discussion about whether we’d want to use more Cursor over hire another engineer. We unanimously agreed we’d rather hire another team member. I’m more productive than ever but I’m burning out.
Anyway, as a result, I switched to Claude Code Max and I am equally as prolific and paying 1/10th the price. I get my cake and to eat it, too. *Note there’s a Cursor Ultra, which at quick glance seems akin to Claude Code Max. Notice that both are individual plans, I believe I’m correct you benefit from choosing those token-wise over a team or enterprise plan?
Anyway, you’re right Claude Code is less ergonomic; generally slower. I was losing my mind over Opus in Cursor spinning up subagents. I don’t notice that happen nearly as frequently in Claude Code itself. I think it has to do with my relatively basic configuration. CC keeps getting better the more context I feed it though, which is stuff like homegrown linters to enforce architecture.
All to say, Cursor’s pricing model is problematic and left a bad taste in my mouth. Claude Code seems to need a bunch of hand holding at first to be magical. Pick your poison
> Anyway, you’re right Claude Code is less ergonomic; generally slower.
The secret in my experience is parallelization - Cursor might be faster or have better ergo for a single task, but Claude Code really shines when you have 6 tasks that are fairly independent.
If you treat CC as just another terminal tool and heavily use git worktrees, the overall productivity shoots through the window. I've been using a tool called Ouijit[1] for this (disclosure: the dev is an old colleague of mine), and I genuinely do not think I could go back to using Cursor or any other traditional IDE+agent. I barely even open the code in an editor anymore, primarily interacting through the term with Vim when I need to pull the wires out.
Cursor can do that well too. Their code review feature usually gives a handful of independent feedbacks. I just trigger agents independently for all of those. Other integrations with Linear and Slack are also very handy to getting into this workflow. Seems like the 3.0 version is aiming at getting better at this use case.
FWIW I'm not saying Cursor is not capable of this, but that all of the 'Cursor' bits are superfluous, and using tools that bring you closer to the 'bare metal' of the terminal actually give you both more flexibility (I can run Claude Code, Crush, Codex, OpenCode, etc) and remove an entire layer of abstraction that I believe hinders a devs ability to really go all in on agentic engineering.
I started using Cursor and it was my daily driver for a year or two, but I haven't looked back once in regret moving more towards a terminal focused workflow. (Not to mention the pricing of Cursor being absolutely abysmal as well, although often comped by employers)
long term claude code user here, never used cursor, however based on my limited experience, it seems codex can code better than claude code.
I've been using Codex since before ChatGPT (the OG version) and CC since launch. For me personally - Claude Code with Opus/Sonnet generally has better taste, more personality in interactions, and is more willing to just do the work. Paired with skills, LSPs, linters, and hooks, it works very well. I think of the two like this:
Claude Code with Opus/Sonnet is the L7 senior engineer still gunning for promotion. Hasn't hit burnout, hasn't been ground down by terrible teams yet. Capable and willing to get their hands dirty. Codex (the harness) with GPT-5.4 or 5.3-codex is fantastic but terse. Some of the UX frustrates me. I want a visual task list. That said, Codex as a harness is phenomenal. Think of it as the senior EM / CTO-in-waiting who won't write new code without complaining and nitpicking for hours. But they'll thoroughly tear your code apart and produce a plan you can execute yourself or pass to Claude Code.
Both are great, and so is Factory Droid. Also worth checking out Compound Engineering from Every.to if you haven't.
here is example of project i worked using codex, it took 10 iterations just to get github actions right https://github.com/newbeelearn/whisper.cpp . you can see the commits made by codex. Project was quite simple it needs to modify whisper to add support for transcribing voice with start/stop keys and copy the transcription to clipboard when stopped. That's it. It performs poorly as compare to CC which gets it right in one shot.
There’s a reason it’s 10x cheaper. You’ll be paying the real price after the subsidies end.
There is no Max sub for enterprise AFAIK, are you using a private plan for work?
Yes. This seemed to be more cost effective.
It is. Those plans are probably priced at marginal cost. Enterprise is 4x the cost or more.
The workflow that got me into Cloud Code was instructing it that whenever I create a new feature or bug, it should make a new git worktree. And then when I'm done, merge that back to main and delete the worktree. That enables me to open up three plus different Cloud Code's and work on three different things at the same time. As long as they're not directly overlapping, it works great.
I find it interesting that you are on the enterprise plan and are not default willing to pay more for more intelligence. Most people I know who are on the enterprise plan are wishing there existed a 2x intelligent model with 2x price.
My company is going through the exact opposite, so it kinda depends on the company. We are actively encouraging our devs to NOT use Cursor because of how much more expensive it is compared to other tools we have from our calculations and they even considered dropping Cursor at contract renewal altogether due to their costs being higher than other tools.
2x intelligence != 2x results
most tasks I can do better and faster with composer 2
a fellow engineer reported a bug on a code I had written a few months back. I used his report as prompt for composer 2, gpt-5.4-high and claude-4.6-opus-max-thinking. composer found the issue spot on. gpt found another possible vector a couple of minutes later, but a way less likely one and one that would eventually self heal (thus not actually reproducing what we observed on production). claude had barely started when the other two had finished
also, i don't have a budget per se. but it is expected that i over deliver if i'm over spending
the only guy in my whose code has more problems than others is the one who who uses cursor, am I missing something?
I used to have a pro-cursor subscription, but it was way too expensive because I'd always hit my limit. I realized I could just use claude code + the free version of cursor for autocomplete and it worked even better. At this point, I'm not understanding the value that cursor is bringing. A souped up claude code? All I have to do is wait a few months and anything useful will be in claude code or codex or whatever.
So unfortunately this is it for me too. I liked Cursor as a tool, but when i switched to Claude I realized i was getting WAY better value for money. I spent $1800 the month before, i spent $200 the next.
I'm now switching between Claude and Codex for less than 1/4 of what I was spending in December.
Yeah, I tried using their Composer model (which I guess is Kimi) and it just feels sub-Sonnet to me. Whereas a Claude Max sub gets me more Opus than I can use in a month.
Which sucks because Cursor is clearly better than Anthropic at building UIs. CC desktop is buggy af.
Codex is nearly Opus level though. Anyone know if OpenAI permits Max subs to be used in Cursor?
I echo the others' sentiments that I still strongly prefer to write code mostly manually, assisted by Tab completions, and only generate piecewise via Cmd+K where I'm not sure about APIs or forgot the exact syntax. Chatting in Ask only mode about more complex problems.
Maybe I'm not a 10x developer, I'm fine with that.
Cursor shoving Agents down my throat made me abandon and cancel it once this year. I jumped around between Sublime, Zed, VS Code, and alas none of them has a Tab completion experience that even remotely compares with Cursor, so I had to switch back.
If possible, I'll probably stay on v2 until it's deprecated. Hope Zed catches by that time.
Try Mercury by Inception. It's available as autocomplete in Zed. Last time I tried it, Zed had an API key hidden in their docs that allowed you to use it for free
The crazy thing is that it's a diffusion-based LLM. That makes it very fast, like Cursor Tab, and the outputs seem very accurate in my limited testing (although I find Cursor Tab to still feel "like 10% better")
---
That said, you should really give agentic coding a la Claude Code a try. It's gotten incredibly good. I still need to check the outputs of course, but after using it for 2-3 days, I've learned to "think" about how to tackle a problem with it similarly like I had to learn when first picking up programming.
Once I did, suddenly it didn't feel risky and weird anymore, because it's doing what I would've done manually anyways. Step by step. It might not be as blackboxy as you think it is
You might want to try this, one step ahead of Ctrl+K
Define the interface and functions and let the AI fill in the blanks.
Eg: I want XYZ class with methodFoo and methodBar which connects to APIabcd and fetch details. Define classes for response types based on API documentation at ...., use localLibraryXYZ for ABCD.
This is the way I found to work well for me. I maintain a tight grip over the architecture, even the low level architecture, and LLM writes code I can't be bothered to write.
I find tab completions very irritating. They're "almost" correct but miss some detail. I'd rather review all of that at once rather than when writing code.
My view about coding agents is that there can't be any human that types as fast as them with the same accuracy as their output, ever!
Same as it is faster to take notes with a laptop than writing manually, it is faster and cheaper to have an agent give you the code you want to type than actually typing them, manually.
how did Cursor shove agents down your throat? Even in this new version it's basically just VSCode with an optional agent sidebar
Unfortunately, I think Cursor is making progressively more difficult to use other AI provider via extension, mostly due to the fact that they are reserving the secondary sidebar for their own chat interface. This makes it super unpractical to use the Codex and Claude extension, as now they all need to share the primary sidebar. (Before it was not optimal, but it was at least possible.)
As many have pointed out, the cost of token via Cursor is prohibitive compared to having a CC or Codex subscription, so I think the new update brings little to current users, but reduces Cursor's usability.
I think Cursor should go in the direction of embracing other provider's extensions and go for a more integrated and customizable IDE, rather than a one-solution-fits-all kind of an approach. Today I opened VSC again after a log time.
I use Zed. Much less user hostile.
The premise of Zed is quite appealing, but I'm not sure I'm ready to switch due to the missing extension ecosystem of VSC. For example, at the moment I'm using the Playwright and Vite ones to quickly run and debug tests.
I wanted to like zed, but then I discovered it is limited to one concurrent agent tab and that is a dealbreaker..
It's open source, so you could try to have your agents patch it! You can also just load up agents in terminal tabs.
I don't use concurrent agents much though so I can't really relate.
How does Zed compare to let's say vsc
Hard to say. I haven't launched VS Code or any of its derivatives since I first used Zed.
I mean it makes sense for them to be somewhat antagonistic towards these flows because every time you use a different agentic extension or tool inside of Cursor, Cursor loses your money and data.
They're also churning with enterprise customers because for lots of customers on next contract renewal their pricing is increasing like 4-8x (depending on usage patterns but this was what we calculated for most of our devs) because they are slowly moving enterprise customers to usage based only plus a surcharge per million tokens, which they already did with personal sub customers, and all of the latest models are becoming Max mode only. My company is currently going through this and we've committed to way less spend with Cursor for our renewal and are signing with Anthropic and telling devs to prefer using claude code instead. I wouldn't be surprised if next year we cancel altogether and tell all devs to go back to VSCode or some other preferred editor.
I don't see a world where Cursor continues to be viable for 5-10 more years. Lots of people were originally saying "the moat is not in being an model provider" for agentic tools and thats turning out to be very much false in my opinion at least if you care about being a business.
yeah good point. I think this is to be seen though. Right now AI tokens, especially via OpenAI/Anthropic subscriptions, are heavily subsidized. If token cost between the API and subscriptions should even out though, then I think Cursor might well be back in the race.
Man, I wish they'd keep the old philosophy of letting the developer drive and the agent assist.
I feel like this design direction is leaning more towards a chat interface as a first class citizen and the code itself as a secondary concern.
I really don't like that.
Even when I'm using AI agents to write code, I still find myself spending most of my time reading and reasoning about code. Showing me little snippets of my repo in a chat window and changes made by the agent in a PR type visual does not help with this. If anything, it makes it more confusing to keep the context of the code in my head.
It's why I use Cursor over Claude Code, I still want to _code_ not just vibe my way through tickets.
My guess would be this is less driven by product philosophy, more driven by trying to maximise chances of a return on a very large amount of funding in an incredibly tough market up against formidable, absurdly well-funded competitors.
It's a very tough spot they're in. They have a great product in the code-first philosophy, but it may turn out it's too small a market where the margins will just be competed away to zero by open source, leaving only opportunity for the first-party model companies essentially.
They've obviously had a go at being a first-party model company to address this, but that didn't work.
I think the next best chance they see is going in the vibe-first direction and trying to claim a segment of that market, which they're obviously betting could be significantly bigger. It's faster changing and (a bit) newer and so the scope of opportunity is more unknown. There's maybe more chances to carve out success there, though honestly I think the likeliest outcome is it just ends up the same way.
Since the beginning people have been saying that Cursor only had a certain window of time to capitalise on. While everyone was scrambling to figure out how to build tools to take advantage of AI in coding, they were one of the fastest and best and made a superb product that has been hugely influential. But this might be what it looks like to see that window starting to close for them.
It is interesting that i find composer to be one of my favorites as while it is a bit dumb it is about 100x faster than the fat boys.
Sometimes u need the beef of opus but 80% composer is plenty.
I have been on the fence if I think composer is useful, but the speed argument is one I hadn’t really considered. I use cursor with Opus almost exclusively but the other day I tried using OpenCode locally with a 6-bit quantized version of Qwen 3.5 and holy crap the speed and latency were mind blowing. Even if not quite as sharp as big boi Opus and the gang.
Now you’ve got me thinking I should give composer another go because speed can be pretty darn great for more generic, basic, tasks.
> It's a very tough spot they're in.
It's a very tough spot they put themselves into. If the goal wasn't to get filthy rich quick it would probably be possible to make a good product without that tough spot.
Products don't live because they're good. They live because they provide value for a short amount of time.
Nothing lives forever. The life of a product is short and over in the blink of an eye.
They're playing this game optimally for their present station.
Slow coding an IDE? We might not even have IDEs in six years.
It's heartbreaking to write this, but I think Cursor will be remembered as the Lotus 1-2-3 of AI coding.
As these products mature people are going to see more of this stuff. These are the contours of the market. The technology is incredible but it’s still subservient to the economics of building products.
It’s the “why can’t Facebook just show me a chronological feed of people I follow”. Because it’s not in their interests to do so.
Yeah, and just like all social media platforms adopted short form video sooner or later they are going to give in to what consumers pay for (in attention or money). Right now it's anyone's guess what that might be in the context of software development.
Tried the cursor a few times, apart from a fancy layer on top of VS Code, it is way too expensive to use, it runs out of credit in a few tasks. On the other hand, vs code with copilot is slower and less 'intelligent', but it lasts longer, I get more work done with it. Recently, started using opencode inside vs code, it is similar to claude code, but needs some better integration with vs code.
The cancer: growth at every cost or die.
God forbids you make a great product in a specific niche and are happy with the money flowing.
Nope, has to be more.
> They've obviously had a go at being a first-party model company to address this, but that didn't work.
I thought there was an entire initiative to build their own coding model and the fine tunes of in Composer 1.5 and Composer 2 were just buying them time and training data
You know, it’s stuff like this making me think maybe the anti capitalists have a point.
A company makes a popular product customers like, but to satisfy the VCs the company must make a product the customers don’t like but could make the VCs more money.
Not sure this is the “invisible hand” Adam Smith had in mind.
"Invisible hand" doesn't force you to take VC funding. You can maintain (and many do) what VCs like to derisively call "lifestyle business". And GNU project somehow wasn't started in Soviet Union either. Editors of both kinds (non-VC funded business and FOSS) are widely available for you to use BTW.
The problems that Cursor is facing are directly resulted by the choices that its founders freely made previously.
Anti-capitalist here: Our point is actually the same point as the one Anti-feudalists had. The consumer hostility observed under capitalism is simply a corollary.
To be fair feudalism (the row-farming kind) kind of collapsed because people found better deals with the rise of trade and mercantilism and such. It wasn’t anything anybody needed to make points over.
IDEs seem headed in the same direction. Seriously, watching Codex rip apart binaries in parallel and Claude go from nothing to app in one prompt, I’m pretty sure there’s no need for me to look at any code. I’m fine using tools that just emit machine code if that’s more efficient.
What if the generated app is sending your sensitive information back to Anthropic?
It is easier to imagine the end of the world then the end of feudalism.
I kind of like the story of how Malthus had his theory of societal collapse because he couldn’t imagine a better system then mercantilism. That societies would rather collapse then to end their colonial monopolies.
I see a similar theory today with around depopulation, that as society gets older and relatively fewer working age people there are, that society would rather collapse then we find a better system then Capitalism.
What system works better when you have a very large number of elderly people who want to retire and very few young people to work?
Socialism, for one.
You still have many people consuming and not producing, and much fewer people producing.
Capitalism or socialism doesn’t change that.