I could probably go much lower, and find a model that is dirt cheap but takes a while; but right now the cutting edge (for my own work) is Claude 4 (non-max / non-thinking). To me it feels like Cursor must be hemorrhaging money. The thing that works for me is that I am able to justify those costs working on my own services, that has some customers, and each added feature gives me almost immediate return on investment. But to me it feels like the current rates that cursor charges are not rooted in reality.
Quickly checking Cursor for the past 4 day period:
Requests: 1049
Lines of Agent Edits: 301k
Tabs accepted: 84
Personally, I have very little complaints or issues with cursor. Only a growing wish list of more features and functionality. Like how cool would it be if asynchronous requests would work? Rather than just waiting for a single request to complete on 10 files, why can't it work on those 10 files in parralel at the same time? Because now so much time is spend waiting for the request to complete (while I work on another part of the app in a different workspace with Cursor).
They don't make any money. They are burning VC money. Anthropic and OpenAI are probably also not making moeny, but Cursor is making "more no money" than others.
This is based on what I've read here: https://www.wheresyoured.at/openai-is-a-systemic-risk-to-the... (big AI bear, for what it's worth)
edit: Well, if they shed the other expenses that only really make sense when training future models (research, more data, fewer employees ..) they would be pretty close to break even.
It's like a horse race.
But yeah enjoy the subsidies. It's like the cheap Ubers of yesteryear.
The more interesting, novel, and useful work you wrap the LLM in the more defensible your pricing will be.
That said I think this can describe a lot of agentic code tools - the entire point is that you're not just talking to the raw LLM itself, you're being intermediated by a bunch of useful things that are non-trivial.
I see this with Anthropic most - they seem to have multiple arms in multiple lines of business that go up the abstraction ladder - Claude Code is just one of them. They seem to also be in the customer service automation business as well.
[edit] I think a general trend we're going to see is that "pure" LLM providers are going to try to go up the abstraction ladder as just generating tokens proves unprofitable, colliding immediately with their own customers. There's going to be a LOT of Sherlocking, and the LLM providers are going to have a home field advantage (paying less for inference, existing capability to fine-tune and retrain, and looooooots of VC funding).
However they will benefit in a way like they benefit from faster server processors: they still have competition and need to fight to stay relevant.
The customers take a lot of the value (which is good).
While there is a lot of fear around AI and it's founded I do love how no one can really dominate it. And it has Google (new new IBM) on it's toes.
They do need to develop sustainable end-user products, or be purchased by larger players, or liquidate.
It's hard to add sophisticated abstractions though, because they are all selling text by the pounds (kilos?). So it feels the same as vendor lock for a cucumber seller, doesn't it? The seller can sell you an experience that would lock you in, but aside from it there is no moat since anyone can sell cucumbers.
It doesn't take much more of a stretch to imagine teams of agents, coordinated by a "programme manager" agent, with "QA agents" working to defined quality metrics, "architect" agents that take initial requirements and break them down into system designs and github issues, and of course the super important "product owner" agent who talks to actual humans and writes initial requirements. Such a "software team system" would be another abstraction level above individual agents like Codex.
As native LLM task completion horizons increase another order of magnitude, so much of this falls out of the window.
Inference cost is plummeting. It’s like the cheap Ubers of yesteryear, if the cost of hiring a driver dropped by a factor of a thousand in the past three years.
> The cost of LLM inference has dropped by a factor of 1,000 in 3 years.
— https://a16z.com/llmflation-llm-inference-cost/
AI startups are not profitable because they are throwing vast sums of money at growth and R&D, not because inference is unaffordable.
You are asking if infinite usage is affordable.
Pet food is not subsidized in my country nor the EU. If any countries do subsidize pet food, they are the exception. Maybe the US? Pet food is often manufactured from the waste of other processes, including the human food industry, but that is not a subsidiary.
This also goes to a personal issue that why would you feed your pet a waste product. My dog gets food I cook for him just like myself. There are tons of crock pot recipes online for safe cheap high quality dog food.
<rant>
Think of it like this: imagine if lactose-free or gluten-free food could be bought only with a prescription. Sadly the prices are already high as it is for gluten-free, but I would rather not get into the reasons here. :)
My girlfriend (LA, US) just left 1k USD on 2 visits to the vet with her cat, for some cheap ass antibiotics, and a "specific prescription-only food". Crazy. All that would have been "free" (not quite, but you know) or at a very low cost for humans around here, in Europe. Not the gluten-free food though!
</rant>
Switching costs are zero and software folks are keen to try new things.
That makes the opportunity cost of switching significant.
(I'm not really a coder/programmer/engineer).
You can open up to three parallel chat tabs by pressing Cmd+T
Each chat tab is a full Agent by itself!
What does this measurement mean?
1049 / (4 * 8) ~= 32 seconds, on average. Doesn't look like much waiting to me.
The problem with generative ai workloads: The costs rise linerly with the number of requests, because you need to compute every query.
Both are genuine questions.
I have used or rather use Claud with CoPilot and I find it pretty useful but at times it gets stuck in niche areas.
Also another issue I am starting to see is the lack of shared MCP servers. If I have VSCode, Cursor, and Claude open, each one is running its own instance of the MCP server. You can imagine that with a dozen or so MCP's, the memory footprint becomes quite large for no reason.
I don’t think the future of agentic software development is in an IDE. Claude Code gives me power to orchestrate - the UX has nothing to do with terminal; it just turns out an agent that lives on the OS and in the filesystem is a powerful thing.
Anthropic can and will evolve Claude Code at a pace cursor cannot evolve IDE abstractions. And then yea - they are designing the perfect wrapper because they are also designing the model.
Long bet is Claude Code becomes more of an OS.
It… sure is something. I’m still thinking about if it’s horrible, visionary, or both.
> Automate Content: Like this very post. I use Wispr Flow to talk with Claude, explain the topic and tell it to read my past blog posts to write in my style.
This is why I think the future may be less about “agents” and more about “intelligent infrastructure”
I don’t want to chat. I want to point a wand and make things happen.
What I did do, because my personal projects aren't too complex, is moved the model from Opus to Sonnet which is about 1/5 the cost.
For day-to-day stuff I have ProxyAI (on IntelliJ, continue.dev works for this too) pointed at Mistral's Codestra for auto-complete and to Claude 4 for chat.
Claude Code is just for giving the bot tasks to do without me being deeply involved in the work.
(edit) I just saw that pro is getting a rate-limited option for Claude code for the sonnet model only. I haven't tried it out but will give it a go sometime. https://support.anthropic.com/en/articles/11145838-using-cla...
The core suggestion is to point specifically at the files you want it to read and use as a reference, otherwise it might go read some huge file for no reason. Also the tokens used depend on the size of the project.
Generally, if I'm doing something I can box, I'd use chatgpt and copy it in myself. If I want something matching the style, I'd use a guided Roo Code.
Besides, if you want something inexpensive, using Gemini 2.0 Flash as a backend is completely free. Google provides an API key at no cost.
Didn't try anything agentic within Emacs yet, don't find that helpful enough so far.
As of last week you can insert a link to a plain-text file in a chat buffer to include its contents in the prompt. It must be on a line by itself. In Markdown it looks
[like this](/path/to/file)
with Org links in Org chat buffers.
This feature is disabled by default to minimize confusion. To enable it you can flip the header line button that says "ignoring media" to "sending media". This works for sending images and other media too, if the model supports it.
I have a global bind for gptel-send (C-c g).
Then, in any buffer, I typically type C-u C-c g.
This lets me customize the prompt and lots of parameters, such as the context, before gptel-send is actually called.
My only wish is that Cursor had partnered with Zed. vscode isn't enjoyable.
The $200 plan so far has been fine. Only had it once that it looked like I might hit the limit soon, but that was a very heavy refactoring task
Why is that?
Unless you do nothing else with your time I'm not sure how you'd utilize the $100/mo plan fully.
I admit their transparency around limits is a bit questionable. Why don't they just list out the tokens and remaining time?
Sometimes I'll just experiment with weird stuff and end up reverting it or delete it afterword's. Also fun to build really nice data visualizations for data I'm working with.
If it is delivering that value indeed, then 100-200 dollars each month is exactly what that professional SWE is worth.
That SWE is going to have to pivot into something adjacent to provide value-add, and if the only value-add is "I can review and approve/reject", then it's only a matter of time[1] that there are no SWEs who can review and then approve/reject.
And that is assuming that the LLM coding performance remains where it is now, and does not improve to the review, orchestration, design and planning levels.
-------------------------
[1] Due to attrition
> Pro ($20/month): Average users can send approximately 45 messages with Claude every 5 hours, OR send approximately 10-40 prompts with Claude Code every 5 hours. [0]
I can probably run through that in 5 minutes.
[0] https://support.anthropic.com/en/articles/11145838-using-cla...
Cursor is essentially only the wrapper for running agents. I still do my heavy lifting in Jetbrains products.
It actually works out well because I can let Cursor iterate on a task while I review/tweak code.
Using Windsurf plugins in JB ides has been working for me, albeit not as powerful yet as the Windsurf VS Code fork.
Last time I tried, it didn't support RubyMine (whomp)
Knowing what tools are better for what really helps.
https://github.com/tuananh/hyper-mcp
it's a MCP server with WASM plugin system, packaged, signed & published via OCI registry.
The one issue I've run into is that the VSCode version Cursor uses is several months old, so we're stuck using older extensions until they update.
``` { "extensionsGallery": { "serviceUrl": "https://marketplace.visualstudio.com/_apis/public/gallery", "itemUrl": "https://marketplace.visualstudio.com/items", "cacheUrl": "https://vscode.blob.core.windows.net/gallery/index", } } ```
https://github.com/getcursor/cursor/issues/2195
This is technically against the ToS of the extension gallery though
This is good user feedback. If Cursor is "Claude + VSCode", why do you need the other 2 open?
Autocomplete: yes
Asking questions: yes
I know everybody is all into agent mode and it isn't a Cursor specific thing, I'm just confused why everybody is into it.
my usecases have been building relatively self-contained, well-specified components of distributed systems out of academic papers and my own design notes / prototype skeletons, in rust. there’s a lot of context for the agent to ground against, and it can blow out ideas into their implications relatively well ime.
the experience of fixing up lots of pesky mistakes that you yourself would never make is kinda annoying.
i wrote a MCP with plugin system where you only need to run 1 instance and add plugins via config file.
We recently launched Zapier MCP, we host the servers for you: https://zapier.com/mcp
STDIO MCP is really just a quick hack.
I’m particularly interested in the release of BugBot. The docs mention it looks at diffs but I hope it’s also scanning through the repository and utilizing full context. Requesting copilot to do a review does the same thing but because it’s only looking at diffs the feedback it provides is pretty useless, mainly just things that a linter could catch.
And every time I find it having diverged further from VSCode compatibility.
This wouldn’t be so bad if it was an intentional design choice but it seems more that Microsoft is starting to push them out? Like MS Dev Containers plugin is still recommended by some leftover internal, but if you install it you get pushed to a flow that auto uninstalls it and installs Remote Containers by Anysphere (which works differently and lacks support for some features). And I end up rebuilding my Dev Container once more… I also noticed recent extensions such as the Postgres one from MS also doesn’t exist.
Cursors tab predictions are still a bit better and snappier but I feel like Zed is a better editor experience over all and I don’t rely on AI anyway. Agent mode works pretty well for me though. Also cursor leaks memory pretty bad for me.
There’s still room for improvement but Zed is working on fixes and improvements at a high pace and I’m already pretty happy with where it’s at.
Had similar issues earlier, now it works.
Also it's great that I do not need to use the vscode ecosystem. Zed is snappy, has a great UI and now a good assistant too.
It feels almost as if VSCode is not adding new features and is in maintenance mode for now. I have no idea if that's actually true, but if this continues, a fork will be easily maintainable.
where is the splashy overproduced video? where is the promises of agi? where is the "we are just getting started" / "we cant wait to see what you'll build"? how do i know what to think if you aren't going to tell me what to think?
edit: oh haha https://x.com/cursor_ai/status/1930358111677886677
When reviewing the changes made from agent mode, I don’t know why the model made the change or whether the model even made the change versus a tool call making the change. It’s a pain to go fish out the reason from a long response the model gives in the chat.
Example: I recently asked a model to set up shadcn for a project, but while trying to debug why things looked pretty broken, I had sift through a bunch of changes that looked like nasty hallucinations and separate those from actual command line changes that came from shadcn's CLI the model called. Ended up having to just do things the old fashioned way to set things up, reading the fine manual and using my brain (I almost forgot I had one)
It would be nice if above every line of code, there’s a clear indication of whether it came from a model and why the model made the change. Like a code comment, but without littering the code with actual comments
Hand written code needs to be distinguishable and considered at a higher priority for future code generation context
It’s called git!
Even if you were willing to deal with your agent making commits and having to fiddle with git to break those up or undo them or modify them, it still doesn't solve OP's need. They want to know what bits of diff apply to which thinking tokens. The prompt and the output are necessary, but there's no mapping between the final diff and the stream of tokens that came out of the LLM (especially in a commit). But that information is known by the tooling already! When generating the diff, the LLM had to output code changes. So you can map those changes to where they originated from. It's not just "what did I tell the LLM to get this change" it's "what was the thought process that the LLM went through after getting my prompt to end up with this line change"
When Ampcode took it all away from me, I found I enjoyed the actual AI-assisted coding much more than configuring. Of course, largely because it just worked. Granted, I had enough experience with other AI tools to manage my expectations.
My recommendation to anyone is to use ask the most then tell it to “implement what we discussed” when it looks good.
Hope that helps
In my experience, next edit is a significant net positive.
It fixes my typos and predicts next things I want to do in other lines of the same file.
For example, if I fix a variable scope from a loop, it automatically scans for similar mistakes nearby and suggests. Editing multiple array values is also intuitive. It will also learn and suggest formatting prefences and other things such as API changes.
Sure, sometimes it suggests things I don't want but on average it is productive to me.
It's also somehow tracking what I look at, because I can look up an API and then return to the original source file and the first autocomplete suggestion is exactly what I was looking up, even though there would be no context to suggest it.
It's really quite magical, and a whole different level from Copilot.
That hasn't been my experience with Copilot next edit feature.
It often understands exactly what I'm doing and I'm able to just tab tab around the file. Like my example about variable loop scope fixing.
My experience is that Copilot does everything you said including considering files I viewed previously to better understand what I'm trying to do.
Its so painful - the model never knows the directory in which it is supposed to be and goes on a wild goose chase of searching in the wrong repo. I have to keep guiding it to the right repo. Anyone here has had success with such a setup?
Keep it short. It's enough for it to realize it needs to navigate directories.
I just have a bunch of markdown files with various prompts that I drop into context when I need them.
Developers use Vim, JetBrains, Emacs, VSCode, and many other tools—what makes you think they’ll switch to your fork?
I think this is an artifact of Cursor being a closed-source fork of an open-source project, with a plugin architecture that's heavily reliant on the IDE at least being source-available. And, frankly, taking an open-source project like VsCode and commercializing it without even making it source-available is a dishonorable thing to do, and I'm rooting against them.
Overall, I am having hard time with code autocompletion in IDE. I am using Claude desktop to search for information and bounce off ideas, but having it directly in IDE – I find it too disturbing.
Also there is this whole ordeal with VSCode Marketplace no longer available in Cursor.
I'm not saying AI in IDE is bad, it's just I personally can't get into it to actually feel more productive.
Also, Trae being $10 for more requests makes Cursor far less appealing to me.
Rust is easier for me than shell scripting so I started writing what I needed and remembered Zed added agent mode. I decided to give it a shot. I had it use Claude 4 with my api tokens.
It wrote the entire program, tested it, debugged it. It made some bad assumptions and I just steered it towards what I needed. By the end of about an hour, I had my complete fix plus an entire ZFS management layer in Rust.
It did cost $11, but that is a drop in the bucket for time saved. I was impressed.
Just sharing this because I got real and measured value recently that is way beyond the widely shared experience.
As an aside: $11 for an hour of Claude 4 seems expensive? I’ve been using Claude 4 (through a Zed Pro subscription, not with my own keys) and I haven’t hit the subscription limits yet. Were you using burn mode, or?
Using my own API tokens is effectively equivalent to "burn mode" when using Zed's subscription model.
At the current pricing, I value my time more than these costs and maintaining context can save a lot of time as opposed to maximizing context vs cost.
Cursor—the fastest-growing AI code editor in the world, reaching $300 million in annual recurring revenue just two years after its launchIf you sell $1.00 USD for $0.90 you can get nearly unlimited revenue (until you run out of cash).
* BYO model or not
* CLI, UI, VSC-plugin or web
* async/sync
* MCP support
* context size
* indexed or live grep-style search
There's probably like 10 more.
Does anyone know if it's GitHub-only or can it be used as a CLI (i.e., Aider replacement)?
Anyway https://github.com/SWE-agent/SWE-agent/blob/v1.1.0/docs/usag... and https://github.com/SWE-agent/SWE-agent/blob/v1.1.0/docs/conf...
Recently, there was a post with detailed evidence suggesting Cursor was intentionally throttling requests [1], including reverse engineering and reproducible behaviors. The team initially responded with a "happy to follow up", but later removed their replies that got downvoted, and banned the OP from posting further updates.
Their response sounded AI-generated too, which wasn't very surprising based on the way they handle customer support [2]. I wish they were more open to criticism instead of only claiming to be transparent.
[1] https://www.reddit.com/r/cursor/comments/1kqj7n3/cursor_inte...
Maybe in the US? I will never pay 100$ for a subscription and I despise that people normalized it by even buying this stuff instead of saying "no, that's way too expensive".
Soon it will be the same for developers. Developers really are a spoiled bunch when it comes to paying for things, many will balk at paying $99/year just to publish stuff on an App Store. Everyone just wants free open source stuff. As expectations on developer productivity rises, you will be paying for these AI tools no matter how expensive they get, or you will just be gentrified out of the industry. The choice is yours.
Things have a price for a reason. It’s up to you whether it’s worth paying that or not.
I’m trying to convey that if a tool increases your efficiency by more than it costs then it’s worth paying for it regardless of how expensive it is. It’s how the economy works.
Edit: On the other hand, the state of the art tools will also be much better in a year, so might keep that high price point!
Am I rationalizing my purchase? Possibly. If I'm not using it daily, I will cancel it, I promise :)
Luckily, it should be coming with the regular $20 Pro subscription in the near future, so it should be easier to demo and get a feel for it without having to jump in all the way.
You can commit checkpoints prior to each major prompt and use any IDE’s builtin visual diff versus last commit. Then just rebase when the task is done
Im super happy with it. I’m not sure how it compares to other coding agents though.
Also had a few misses. But in general it is ok. Still prefer ai assistant, because i can then direct the result into a certain direction. It also feels faster, it probably is not because of the manual stuff involved.
It has showed promise, enough to quell my FOMO about other IDEs, since I am extremely happy with the Jetbrains suite otherwise.
I believe it’ll get much better as LLMs start editing code by invoking refactoring tools (rename, change signature, etc.) rather than rewriting the code line by line, as this will let them perform large-scale changes reliably in a way that's similar to how software engineers do them now using IDE tools
Evidently not
It's also missing quite a few features still (like checkpoints, stopping the agent mid-task to redirect, etc). But the core feature set is mostly there.
Do it. I've started editing with Zed and just keeping Cursor/Intellij open on the side. (Cursor b/c of the the free student plan, Intellij for school assignments).
I feel spoiled by the performance, especially on promotion displays. I've started noticing some dropped frames in Cursor and measured an avg of 45-60 fps in Intellij (which is somewhat expected for such a huge IDE). I basically exclusively write in Zed, and do everything else in their respective apps.
That said, I do continue to think that agents are in this weird zone where it's more natural to want to interact through ticketing layer, but you kind of want to editor layer for the final 5%.
Because we're developers with things to build and we don't have time to play with every AI tool backed by the same LLM.
Like it or not, we're hitting the slope of enlightenment and some of us are ready to be done with the churn for a while.
Which is another reason why I'll stick with Cursor. Cursor's tab complete can barely be described as Copilot-style, it's nearly a different paradigm and it's what actually got me to pay for it in the first place. I only tried agent mode because it was included with the bundle.
> from day one
July 5, 2024 if going by initial commit. So, yes, technically before Cursor, but Cursor was building agent mode before Cline drew any attention in the mainstream. Cline's first interest on HN dates back to January.
I'll concede that it appears Cline did get to agents first, but it's still a new development in terms of actually drawing interest.
Cursor Agent works great, too.
Most importantly, everything is $20/month, instead of possibly $20/day with Cline or Roo.
It's just like VSC, which I was using, but it has these magical abilities. I was using it within a minute of downloading it. Unlike Cline, I guess, whatever that is.
You can use the full-context if you prefer that cost/speed tradeoff! Just have to turn on Max Mode.
Cline is great for many users, but a bit of a different product. Lots of Cursor's value come from custom models that run in the background (e.g. Tab, models that gather context, etc.).
There's still a ton of low hanging fruit that other Copilot-style autocomplete products don't seem to be picking up, like using clipboard contents, identifying the next place in the file to jump to, etc.
I primarily save time coding with AI with autocomplete, followed by chat, with agentic flows a very distant 3rd, so Cursor is a legitimately better product for me.
I didn’t say cursor has poor UX.
I tab too. And use agent for cheaper work I don’t care too much about. That said, the best autocomplete is arguably evolving and cursor does not own that.
And your answer is "A lot of power in social influence.", which is a bit silly when autocomplete is the first form of AI assistance a critical mass of people found intuitive + helpful and Cursor has the best implementation of it... meanwhile Cline/Roo Code don't provide it.
Your beloved cursor will go all in on this front, less and less priority on focused cursors in the editor.
And it's not "my beloved cursor", not sure why you're being such an absolute weirdo about this.
Agentic coding is fine, definitely helps me a lot with setup and boilerplate, but finer business logic details and UX changes are now it's strong suit especially if you know WHAT you want but not HOW to explain it in a clear enough format that it can do it without additional prompting.
I’d rather do that than painstakingly put my request into prose, cross my fingers, and hope the “agent” doesn’t burn 100,000 tokens making stupid and unrelated changes all over my codebase.
I believe in “show, don’t tell,” and autocomplete is the former while agents are the latter.
It is more effective when you have to do a bunch of similar changes. Or when code is standard enough that you just hit tab, and change perhaps one line. Or when parts of code are immediately deduced from context, and substitutions/changes are immediately provided.
I’m also curious how this compares to OpenAI’s Codex. In my experience, running agents locally has worked better for large or complex codebases, especially since setting up the environment correctly can be tricky in those setups.
"Cursor works with any programming language. We’ve explicitely worked to improve the performance of our custom models — Tab included — on important but less popular languages like Rust, C++, and CUDA."
Hundreds of languages supported: https://code.visualstudio.com/docs/languages/overview
video demo here, https://x.com/ob12er/status/1930439669130637482?s=46&t=2jNrj...
Cursor a lot of respect from our dev team if todays slack messages are anything to go by
Will be adding the Add to cursor button to Glama later today today.
If anyone from Cursor is reading this, we are rolling out MCP server usage analytics where we aggregate (anonymous) usage data across several providers. Would be amazing to include Cursor (reach me at frank@glama.ai). The data will be used to help the community discover the most used (and therefore useful) clients and servers.
C:\projects\my_project>q^D^C 'q' is not recognized as an internal or external command, operable program or batch file.
1.0 my ass.
* Are you using Cursor as your main editor?
* For more senior engineers -- is it really that much of a productivity boost?
* Is the primary use of an AI editor like Cursor to handle more tedious tasks? Ex: generate an array with all the months, write some unit tests for me for some simple component, write some boilerplate code for me, etc.
Maybe I'm being overcautious, but one of the worst things (for me) that came from the AI rush of these past years is this feeling that everything is full of bots. I know that people have preferences, but I feel that I cannot trust anymore that a specific review was really made by a human. I know that this is not something new, but LLMs take it to the next level for me.
'Connection failed. If the problem persists, please check your internet connection or VPN'
I've contacted support and they have been no help. You can see tons of people having this issue in user forums. Meanwhile, bypassing the giant monstrosity that is VScode (and then a Cursor as a fork on top of it) gives me no such issues.
So I wouldn't be so dismissive that anyone frustrated with Cursor is a bot.
Not GP, but my suspicions are actually of the other end of the spectrum - i.e., it's the glowing reviews of AI things that make my bot-sense tingle.
Though I usually settle on the idea that they (the reviewers) are using LLMs to write/refine their reviews.
You should just set aside some time to try out different tools and see if you agree there's an improvement.
For trying models, OpenRouter is a big time saver.
I hope that I am wrong, but, if I am not, then these companies are doing real and substantial damage to the internet. The loss of trust will be very hard to undo.
- Burning tokens with constant incorrect command-line calls to read lines (which it eventually gets right but seemingly needs to self-correct 3+ times for most read calls)
- Writing the string "EOF" to the end of the file it's appending to with cat
- Writing "\!=" instead of "!="
- Charged me $7 to write like 23 lines (admittedly my fault since I forgot I kept "/model opus" on)
Minus the bizarre invalid characters I have to erase, the code in the final output was always correct, but definitely not impressive since I've never seen Cursor do things like that.
Otherwise, the agent behavior basically seems the same as Cursor's agent mode, to me.
I know the $7 for a single function thing would be resolved if I buy the $100/month flat fee plan, but I'm really not sure if I want to.
Hello,
Your Pro plan just got way more powerful with three major upgrades previously available only to Max, Team, and Enterprise users.
Claude Code is now included
Claude Code is a command line tool that gives you direct access to Claude in your >terminal, letting you delegate complex coding tasks while maintaining full control. You can now use Claude Code at no extra cost with your Pro subscription.The $100/mo max plan lets you use a Claude Code with a fixed bill. There’s some usage limits though.
See this sort of asinine behavior with cursor too sometimes although it's less grating when you're not being directly billed by the failed command line attempt. Also it's in a text editor it fully controls why is it messing around in the command line to read parts of files or put edits in, seems to be a weird failure state it gets into a few times a project for me.
For more than a year, Anthropic has engaged in an extensive guerrilla marketing effort on Reddit and similar developer-oriented platforms, aiming to persuade users that Claude significantly outperforms competitors in programming tasks, even though nearly all benchmarks indicate otherwise.
The GP account above with only one comment that is singing the praises of a particular product is obviously fake. They even let the account age a bit so that wouldn't show up as a green account.
Keep in mind much of the guide is about how to move from 30s chats to doing concurrent 20min+ runs
----
Spending
Claude Code $$$ - Max Plan FTW
TL;DR: Start with Claude Max Pro at $100/mo.
I was about $70/day starting day 2 via the pay-as-you-go plan. I bought in $25 increments to help pace. The Max Plan ($100/mo) became attractive around day 2-3, and on week 2 I shifted to $200/mo.
Annoyingly, you have to make the plan decision during your first login to Claude Code, which is confusing as I wanted to trial on pay-as-you-go. (That was a mistake: do Max Pro.) The upgrade flow is pretty broken from this perspective.
The Max Plan at the $100/mo level has a cooldown of 22 question / 5 hour: That does go by fast when your questions are small and get interrupted, or you get good at multitasking. By the time you are serious, the $200/mo is fine.
Other vibe IDEs & LLM providers $$$
I did anywhere from about 50K to 200K tokens a day on Claude 3.7 Sonnet during week 1 on pay-as-you-go, with about a ratio of 300:1 of tokens in:out. Max Plan does not report usage, but for periods I am using it, I expect my token counts to now be higher as I have gotten much better at doing long runs.
The equivalent in OpenAI of using gp4-4o and o3 would be $5-40/day on pay-as-you-go, which seems cheaper for using frontier models… until Max Pro gets factored in.
Capping costs
Not worrying about overages is typically liberating. Max Pro helps a lot here. One of my next experiments is seeing about self-hosting of reasoning models for other AI IDEs. Max Pro goes far, but to do automation and autonomy, and bigger jobs, you need more power.
How do you own Cursor for 3 years, when even ChatGPT is not that old? The earliest Cursor submission to HN was on October 15, 2023 --- not even 2 years old [0].
And no I'm not a bot but feel as you wish.
I definitely wouldn't be surprised if a small startup was engaging in their own posts, something I do find shameful. But that's quite a far shot from a wildly successful startup with 100M ARR engaging in some kind of scheme where accounts with active history are making automated comments. Just seems not only unnecessary but also unlikely given the risk and effort involved.
I think it's much more likely that out of the 300k users or whatever they have, a lot of them are on hackernews and have good things to say about the product and a 1.0 is a significant event.
What are you doing that costs that much?
I refactored a whole code base in cursor for < $100 (> 200k lines of code).
I don't use completions though. Is that where the costs add up?
You can configure it so that you use your API keys, which means you just pay cost but o3 is expensive
Also, Copilot's paid version is free for developers of popular FOSS projects.
https://docs.github.com/en/copilot/about-github-copilot/plan... / https://archive.vn/HxHzc
I'm not saying it is better if they run commands without my approval. This whole thing is just doesn't seem as exciting as other people make it out to be. Maybe I am missing something.
It can literally be a single command to ssh into that machine and check if the systemd service is running. If it is in your history, you'd use ctrl+r to lookback anyway. It sounds so much worse asking some AI agent to look up the status of that service we deployed earlier. And then approve its commands on top of that.
Running commands one by one and getting permission may sound tedious. But for me, it maps closely to what I do as a developer: check out a repository, read its documentation, look at the code, create a branch, make a set of changes, write a test, test, iterate, check in.
Each of those steps is done with LLM superpowers: the right git commands, rapid review of codebase and documentation, language specific code changes, good test methodology, etc.
And if any of those steps go off the rails, you can provide guidance or revert (if you are careful).
It isn't perfect by any means. CC needs guidance. But it is, for me, so much better than auto-complete style systems that try to guess what I am going to code. Frankly, that really annoys me, especially once you've seen a different model of interaction.
But a beginner in system administration can also do it fast.
And as of the latest release, has VSCode/Cursor/Windsurf integration.
Claude code now automatically integrates into my ide for diff preview. It's not sugar, but it's very low friction, even from the cli.
I have been using the Claude.ai interface in the past and have switched to Aider with Anthropic API. I really liked Claude.ai but using Aider is a much better dev experience. Is Claude Code even better?
ChatGPT Codex is on another level for agentic workflow though. It's been released to (some?) "plus" ($20/month) subscribers. I could do the same thing manually by making a new terminal, making a new git worktree, and firing up another copy of aider, but the way codex does it is so smooth.
They both can just use api credits so I’d suggest spending a few dollars trying both to see which you like.
I still prefer Cursor for some things - namely UI updates or quick fixes and explanations. For everything else Claude Code is superior.
What's the best about it, it's open source, costs nothing, and is much more flexible than any other tools. You can use any model you want, either combine different models from different vendors for different tasks.
Currently, I use it with deepseek-r1-0528 for /architect and deepseek-v3-0325 for /code mode. It's better than Claude Code, and costs only a fragment of it.
Once something, like in this case AI, becomes a commodity, open source beats every competition.
At least Cursor is affordable to any developer. Because most of the time, even if it’s totally normal, companies act like they’re doing you a favor when they pay for your IDE so most people aren’t going to ask an AI subscription anytime soon.
I mean, it will probably come but not today.
> Except that in most of the world outside SV
You just need a 4% increase of productivity to make those $200 worth it.
lolololol
> You just need a 4% increase of productivity to make those $200 worth it.
who “needs” that and who pays for it?
the employer for both?
high school economics class is not how the world works, regrettably.
They'd rather have an employee spend 2 weeks on a task than shell out a few bucks at it, because they don't realize the 2 weeks of salary is more expensive than the external expense.
Plus development work is quite bursty — a productivity gain for developers does not necessarily translate into more prospects in a sales pipeline.
It's companies asking programmers to use AI, not vice versa.
Since the last couple of updates I don't seem to have those problems as prominently any more. Plus it seems to have greatly improved its context handling as well -- I've encountered far fewer occurrences where I've had to compact manually.
Perhaps not coincidentally, that's what efficient (or "lazy", you choose) developers do as well.
am i missing that much ?
You can generally do map-reduce, also you can have separate git worktrees and have it work on all your tickets at the same time.
Traditional code editing -> autocomplete -> file editing -> agent mode
This is basically a gradient of AI output sizes. Initially, with the ability to generate small snippets (autocomplete), and moving up to larger and larger edits across the codebase.
Cursor represents the initial step of AI-assisted traditional coding... but agent mode is reliable now, and can be directed fairly consistently to produce decent output, even in monorepos (IME). Once the output is produced by the agent, Ive found I prefer minimal to no AI for refining it and cleaning it up.
The development techniques are different. In agent mode, there's far more focus on structuring the project, context, and prompts.. which doesn't happen as much in the ai-autocomplete development flow. Once this process shift happened in my workflow, the autocomplete became virtually unused.
So I think this shift toward larger outputs favors agent-focused tools like CC, Aider, Cline, and RooCode (my personal favorite).. over more traditional interfaces with ai-assistance.
Now I've changed my technical planning phase to write in a prompt-friendly way, so I can get AI to bootstrap, structure, boilerplate and usually also do the database setup and service layer, so I can jump right into actually writing the granular logic.
It doesn't save me planning or logic overhead, but it does give me far more momentum at the start of a project, which is a massive win.
The agent stuff is largely useless. The tab prediction go nuts every few seconds completely disrupting flow.
This is my main gripe with it, too. It's still been semi-useful at least for some analysis and examination of our code-base, but editing and autocomplete I've not found super useful yet.
What about Gitlab instead of GitHub, is there an equivalent to cursor 1.0 product?
Git host doesn't really make a difference.
I work in a multinational conglomerate, and we got AI allowed ... 2-3 weeks ago. Before that it was basically banned unless you had gotten permission. We did have another gpt4 based AI in the browser available for a few months before that as well.