
Cursor
The AI Code Editor
5.0•718 reviews•31K followers
The AI Code Editor
5.0•718 reviews•31K followers

31K followers
31K followers
The best coding agent for a while. it is expensive though. you pay a premium price for a premium agent.
pricing is an issue, especially because that different plans that everybody has. there is not enough clarity about pricing. one can spend 2 requests (same for any other model) for an opus 4.6 request, while other can spend 7 dollars
Cursor is just better at using the given model up to its limits. None of the other agentic products success that much. Also plan mode is a beast if you give some time to your task and plan everything carefully. While coding with the popular tech stacks, Cursor executes the plan flawlessly most of the time.
Sometimes there will be a subtle bug that will haunt you for hours, if not days. Everyone who has been coding for a while, especially before the AI era experienced this. Previously, you had to trust the process, not get frustrated, and keep on trying to track down the bug with a clean mind. Software does not progress linearly. Debugging tool on the other hand, can dramatically reduce the cases this situation happening. Sometimes, AI knows more than you about the tiny aspects of your tech stack, therefore it can transform a very painful debugging session into a single prompt and couple of seconds.
On the contrary, I believe it is important to not overuse though. If you let AI do all the thinking work, over time you will lose your debugging skills. When the time comes and AI fails you to debug successfully, you still need that skill so don't overuse.
Almost always helpful. If you feel like it is intrusive, you can always give custom instructions and change your behavior of using AI agents to make you more comfortable. Cursor especially is good for following custom instructions.
Yes, big repositories are not usually a problem. There are optimization problems about big files and big changes though.
Cursor is fantastic because it deeply integrates AI into the core coding workflow rather than treating it as an external tool. It understands project context, code structure, and developer intent, enabling accurate code generation, refactoring, and navigation directly inside the editor. By significantly reducing context switching and accelerating problem-solving, Cursor helps developers write, understand, and iterate on code faster and with greater confidence.
While Cursor is highly powerful, there are areas for improvement. In large or complex codebases, context selection can sometimes be imprecise, leading to less relevant suggestions. More transparent control over which files and symbols the AI is using would help developers better guide the model. Additionally, performance optimization for long-running sessions and clearer feedback when the AI’s confidence is low would further improve trust and usability.
I chose Cursor because it integrates AI directly into the editor in a way that is deeply context-aware and practical for real-world development. Unlike standalone AI tools, Cursor understands the structure of the codebase and supports tasks like refactoring, debugging, and reasoning across files. This makes it a natural extension of the development workflow and significantly reduces context switching while improving overall productivity.
Crashes are rare, and overall stability is good. Minor performance slowdowns can occasionally occur during long sessions or when working with large codebases, especially when extensive context is involved. However, these issues are generally manageable and do not significantly disrupt daily development. Overall, Cursor feels stable enough for regular, production-level development work.
Pair programming with the AI generally feels helpful rather than intrusive. Cursor acts more like an on-demand collaborator that provides suggestions, explanations, or implementations when needed, instead of constantly interrupting the workflow. As long as the developer maintains control over when and how the AI is engaged, the experience enhances productivity and decision-making without diminishing human ownership of the code.
In most cases, the code and tests generated by Cursor are readable, well-structured, and reasonably easy to maintain. The generated logic generally follows common best practices and integrates well with existing codebases. However, maintainability still depends on proper prompt guidance and human review, especially for complex business logic. With clear intent and iterative refinement, Cursor can produce code that is suitable for long-term maintenance rather than just quick prototypes.
Cursor has become one of the most reliable tools in my development workflow. It fits naturally into the way I already write and manage code, and the integration feels smooth from the moment you start using it.
The code suggestions are accurate, context-aware, and genuinely helpful. It works well whether I am writing new features, cleaning up older code, or testing. The speed is consistent, and the editor responds quickly, which makes the entire experience feel efficient.
The autocomplete and code generation features save a noticeable amount of time. It almost works like a quiet assistant in the bac

k
ground, offering improvements without interrupting my flow. Real-time debugging and error detection are strong additions and help resolve issues much faster.
I have attached a few screenshots of Cursor in use to show how it fits into a normal coding environment.
I tested a few other AI-assisted coding tools, but Cursor stood out because of how well it integrates into the actual development workflow. It doesn’t feel like a separate layer added on top of the editor. The editing experience, speed, and context awareness are noticeably better than the alternatives I tried.
Cursor also handles full-file and multi-file changes more reliably, which makes it practical for real projects rather than just small tasks. The balance between automation and control is what convinced me to choose it. It speeds up the work without taking away the flexibility of writing code the way I prefer.
In my experience, multi-location edits work well even in larger projects. Cursor handles related changes across multiple files without losing context, and most edits remain consistent. There are rare moments where it misses one or two references, but overall the feature is reliable and saves a lot of manual effort.
Privacy mode is designed well for handling sensitive code, and it does provide a level of comfort when working with private or client projects. It keeps data local and avoids uploading anything externally. For most use cases, this is sufficient, though developers working with highly confidential material may still want to review their own internal policies.
The inline diagnostics are generally accurate and helpful. Cursor highlights issues with clear explanations, and the suggestions are usually on point. It identifies common mistakes quickly and provides fixes that make sense in the context of the code. It’s not perfect in every case, but the accuracy is strong enough to trust during daily work.
In spite of the pricing strategy issues, it became my de-facto daily driver. I'm so used to Cursor harness I'm struggling to even use its competitors well enough to make comparisons! :D Great job!
Ever since cursor launch, I still get occasional freezes where I'm forced to reboot the app to make it work
I find so much more useful to see what is happening while cursor is answering. That, combined with the extremely good harness, made it quite tough to beat
the bigger the codebase, the worse the performance is, overall. this can be overcome by making cursor to focus on specific folders only, and that improves quite a bit its performance, but overall I open cursor on huge multirepo codebases only when I need to code a well-defined multi-repo flow. That's where it struggles the most and it needs most guidance, but it's still feasible. However, I love how it's so easy to just "open different cursor workspaces on different subfolders" as a way to cope with that
I confess I use a different product with respect of that. Cursor just isn't providing informative enough feedback in there with respect to competitors, and also the fact these analysis cost extra is messing with my current budgeting situation
I'm lucky to work for a company that is pretty tolerant on this. But, overall, that's one of cursor main pain points. ever since it lost its BYOK support, that became a problem. I can only use it in specific environment, due to this

Cursor is one of the original AI code editors (2023 was a long time ago!) and has stood the test of time. It's a VS Code fork, which was key for me. I lean on @VS Code extensions and custom shortcuts. I was able to keep all of them (there is a migration assistant) when moving over to Cursor.
Cursor is very much an editor for looking at code as opposed to a vibe coding tool like @v0 by Vercel. My typical modes of using cursor are:
Describe a feature or a bug using Agent mode in the right sidebar.
Review diff + use AI autocomplete in editor.
I review every line of code an agent outputs. And I find myself editing code quite a bit. The agent still outputs code that is too verbose and, sometimes, not maintainable.
The price is nice too. $20/month is very reasonable.
I find 3 issues with the Auto model mode (as opposed to selecting a specific model):
It can be very verbose. This is where @Claude Code is much better.
Fails on complex problems. I end up selecting gpt-5 manually for these.
Kind of slow. @opencode with Grok Code seems at least 10x faster for simple prompts.
Also, I don't love using a dated fork of VS Code. I have been considering switching to VS Code + @Github Copilot extension since then I would be on the latest, vanilla VS Code.
Finally, Cursor also asks to be updated almost every day, which requires a restart. I like being on the latest software. But the restarts are very annoying. I run dev servers in the in-editor terminal. So I end up needing to restart the dev server every time I restart the editor.
I still use Claude Code quite a bit in a Cursor built-in terminal actually. But it's hard to beat all the editor integrations Cursor includes. Claude Code has just option+cmd+k.
I kicked the tires on OpenCode and really liked it. OpenCode is a terminal agent. So I didn't stick with it.
I used Windsurf for a while, and Windsurf felt like a magical upgrade over Cursor. Over time, it felt like Cursor caught up and then passed Windsurf. Honestly though, I haven't tried Windsurf in a while. Maybe it has advantages over Cursor again?
AI autocomplete is the original feature of Cursor and is very helpful. Saves a ton of typing. If I am in coding mode (as opposed to prompting mode), I'll often write a comment documenting a function. Autocomplete then spits out the function.
I also jump between languages. Honestly, it's pretty nice to rely on autocomplete instead of looking up syntax I forgot.
Hasn't been an issue for me. And I am on a somewhat dated machine (Apple M2 Pro).
This has gotten way better over time. I find that it's still key to include AGENTS.md for the project. But you can use Cursor to help generate that.
Take the above with a grain of salt. I use Cursor with very common languages and frameworks (Ruby on Rails, NextJS, Python). I have heard that Cursor struggles with more boutique languages and projects.


