G2

Muhammed A.

Technical Project Manager

Information Technology and Services

Mid-Market (51-1000 emp.)

8/1/2026

"AI-Native Coding in Cursor That Fits Right Into the VS Code Workflow"

4/5

What do you like best about Cursor?

The AI integration in Cursor feels genuinely woven into the coding workflow instead of bolted on as an afterthought. Inline code generation and chat-based editing pull context from the whole codebase, not just the open file, so suggestions actually match existing architecture and coding patterns rather than generic boilerplate. Tab-to-accept autocomplete is fast and often predicts multi-line edits correctly, saving a lot of repetitive typing during daily development.

The interface stays close to a familiar VS Code layout, so there's almost no learning curve coming from that ecosystem — getting started took minutes rather than a real onboarding process. Extensions and settings carry over smoothly, and the editor stays responsive even in larger projects with many open files. Integration with existing Git workflows and terminal usage feels seamless, and referencing specific files or symbols directly in a prompt makes debugging and refactoring noticeably quicker than switching to a separate AI tool.

On pricing, the value holds up well against the time it saves — faster iteration and fewer context switches easily justify the subscription cost for a small technical team. Support has been reliable when needed, with documentation that covers most common issues, so there's rarely a wait to keep moving. Overall it's become a core part of the day-to-day coding process. Review collected by and hosted on G2.com.

What do you dislike about Cursor?

Pricing gets frustrating once usage scales — the fast request limits on the standard plan get consumed quickly on larger codebases, and hitting that ceiling mid-task means either slowing down to conserve requests or upgrading to a higher tier sooner than expected. More transparency around real-time usage consumption would help, since right now it's often only clear after the fact.

Performance can also dip on very large repositories — indexing takes noticeably longer, and the context window occasionally doesn't fully capture relevant files scattered across a big project, so suggestions miss dependencies living outside the immediate working directory. That means double-checking generated code more carefully on bigger builds than on smaller ones.

The AI still occasionally hallucinates function signatures or library APIs that don't actually exist, especially with less common packages or internal libraries it hasn't seen much of, so verification against actual documentation remains necessary rather than optional. Multi-file refactors sometimes need manual cleanup afterward since the model doesn't always catch every downstream reference that needs updating.

Onboarding new team members to the AI-specific features (custom rules, context management, model selection) takes more explanation than just picking up a standard editor, since getting real value out of it requires understanding how to prompt and scope context effectively. Minor learning curve, but it's there. Review collected by and hosted on G2.com.

What problems is Cursor solving and how is that benefiting you?

Cursor is solving the friction of context-switching between writing code and getting AI assistance — instead of copying code into a separate chat window and pasting suggestions back, everything happens inline within the actual editor. This has meaningfully sped up day-to-day development, especially for repetitive tasks like writing boilerplate, generating test cases, and drafting initial implementations of well-understood patterns.

It's also cut down significantly on time spent debugging, since the AI can scan across multiple files to spot the source of an error rather than manually tracing through the codebase file by file. For a small technical team without dedicated resources for every specialization, this has been a real force multiplier — junior or less experienced developers can move faster on unfamiliar parts of the stack because the AI helps bridge knowledge gaps in real time, whether that's an unfamiliar library, a new framework pattern, or legacy code someone else wrote.

Refactoring large codebases has become considerably less tedious too. What used to mean manually updating dozens of related files can now be scoped and handled in a single pass with AI assistance, with far fewer missed references than doing it by hand. On the documentation side, having AI help generate and maintain inline comments and docstrings has improved code readability across the team, which matters a lot given multiple people touch the same codebase over time.

The net benefit has been faster iteration cycles overall — less time spent on mechanical, repetitive work means more time available for actual architecture decisions, business logic, and problem-solving that requires real judgment. Review collected by and hosted on G2.com.