The Good and Bad of Cursor AI Code Editor

One of the biggest shifts in software development today is the rise of AI coding tools. These tools are helping developers and non-developers write code and launch prototypes and apps faster. Among these tools, Cursor has quickly gained attention as a leading option in the market.

In this article, we’ll take a closer look at Cursor, its pros and cons, and how it stacks up against other AI code editors. This will be an experiential guide where I walk you through my journey using Cursor to build a to-do application. By the end, you’ll have a clear sense of whether Cursor is a good fit for your own development workflow.

Let’s dive in.

What is Cursor?

Cursor is an AI-powered code editor built with VS Code’s open-source codebase. It works like regular code editors but adds integrations with large language models (LLMs) that makes writing, editing, and understanding code easier and faster. Cursor is one of the many AI coding tools that software engineering teams are integrating into their workflows.

Key Features of Cursor AI code editor

Let’s explore the most important capabilities that make Cursor a widely loved solution.

Chat AI assistant

One of Cursor's most vital parts is its AI assistant, which you can access via its chat panel. You can interact with it using natural language prompts to ask questions, request explanations, or generate new code.

The AI chatbot is context-aware and can reference your open files or specific code selections to provide more accurate responses. It supports multi-turn conversations, meaning you can ask follow-up questions or give additional instructions based on previous responses. This allows for a more interactive and iterative coding experience.

The chat assistant isn’t limited to text inputs. You can also upload images, which makes it easier to share visual information. For example, you can upload screenshots of error messages, diagrams, or parts of your user interface. The assistant can then use that image as part of the context for its response.

When creating the to-do app, the first thing I did was pick a free UI design. Then I uploaded the images to Cursor and asked it to generate code for the interface.

Its first result was great. However, I had to fine-tune it slightly to achieve the exact interface I wanted.

The image below shows the completed to-do app generated with Cursor—all in less than 5 minutes! Depending on your coding skills, this could have taken anywhere from 30 minutes to a couple of hours.

One interesting thing I noticed was that even though I only instructed the AI to generate the UI, it went ahead and implemented the functionality as well. From the very first pass, I could already add and delete to-do items without explicitly asking for it.

This behavior isn’t unique to Cursor. When using AI coding tools in general, you have to be extremely precise about what you want and what you don’t want. If you don’t clearly define the task, the AI may go beyond your intended scope.

This is where Cursor’s rules feature comes in, and we’ll explore it later in this article. It allows you to set guardrails and give more specific instructions to the AI. That way, you stay in control of the code generation process and avoid unexpected results.

Cursor AI chat modes

Diving deeper into the chat functionality, let’s explore the different chat modes it offers, their peculiarities, and when to use which one.

Agent mode (default). The most autonomous and powerful mode in Cursor, this is the mode I used to generate the code for the to-do app.

It's designed to handle complex coding tasks with minimal guidance. It can independently explore your codebase, run terminal commands, and identify (or create) and edit relevant files.

This mode helps you build features, refactor code, set up new projects, and make complex multi-file changes. I used it to generate the code for the to-do app.

Manual mode. This mode is for making targeted edits to your codebase. Unlike agent mode, manual doesn't automatically make changes across multiple files. You have to mention the file(s) that need changing and the edits you want. Then Cursor will generate the relevant code for you to review and manually accept—or reject.

To test it out, I switched to manual mode and passed this prompt: “Add a footer.” As expected, it generated the code for the footer. But I wanted to see how strict the manual mode was. So, I took things further and adjusted the prompt: “Add a footer to the page.js file yourself.” Surprisingly, that worked, and Cursor applied the code itself. I’m not sure if it's a bug, but this behavior was interesting to see.

Ask mode. This read-only mode is designed for learning about codebases without changing them. It's also good for understanding a project’s structure and the relationship between its components. A good use case is new hires using it to learn about a new codebase during onboarding. You can also paste error messages and ask the AI to explain what’s wrong without worrying that it’ll suddenly make code edits.

I tested the boundaries of this mode with this prompt: “Change the background color of the webpage and apply the code yourself.” While it generated the code, it did not edit the file—even though the AI said it did.

Custom modes. You can create your own modes by combining different tools and custom instructions to fit your specific workflow. You can also configure whether the AI should automatically run and apply edits in this mode.

You can have a mode just for debugging, another for writing documentation, another for running tests, and so on.

To test it out, I created a “code-docs” mode that only generates code documenation for my codebase. I instructed it to add documentation—and only that—to the to-do app’s code and it did.

To test how strictly the “code-docs” mode adhered to my instruction, I prompted it to change the page’s background color to red. Even though it is only supposed to document code, it surprisingly ignored my instructions and changed the background color. It could either be a bug or because my instructions weren’t strict or robust enough. Again, it's an interesting behavior to see.

Cursor tools

Cursor provides tools that control what the AI can do in your project.

• Read File lets the AI read the contents of a file in your codebase. It can read between 250 and 750 lines of code.
• List Directory enables the AI to view a directory’s structure without reading the contents of its files.
• Codebase allows the AI to perform semantic searches within your indexed codebase.
• Grep lets the AI search for exact keywords or patterns inside files.
• Search Files helps the AI quickly find files by name using fuzzy matching.
• Web allows the AI to perform web searches when needed.
• Fetch Rules enables the AI to retrieve specific rules you’ve set based on their type and description.
• Edit & Reapply allows the AI to suggest and automatically apply file edits.
• Delete File gives the AI the ability to delete files autonomously.
• Terminal lets the AI execute terminal commands and monitor their output.
• MCP servers allow the AI to integrate with external services like databases or third-party APIs through the Model Context Protocol (MCP), which gives AI systems access to external resources.

You can only configure or select specific tools when creating custom modes. The default modes—Ask, Manual, and Agent—come with their own fixed tool settings, and you can’t control which tools they use.

Cursor‘s @ symbol

Technically speaking, the tagging feature is part of the chat interface, but it's so robust that it deserves standalone coverage. This feature is the primary way to add context to your AI conversations.

It's Cursor’s context control and referencing system that lets you explicitly tell the AI what information to consider when responding to your requests. It acts like RAG and helps improve the accuracy of the system’s responses.

Thse are the elements you can reference using “@” in Cursor.

• Files and folders. You can tag specific files or folders in your project to give the AI direct access to their content.
• Code. Referencing particular functions, classes, or components in your code is useful when asking the AI to refactor, document, or modify specific parts of your project.
• Documentation. You can reference documentation to help guide the AI’s responses. Cursor provides built-in references to 30+ official documentation. However, you can also add links to the documentation of other tools used in your project.
• Past chats. You can reference previous conversations with the AI. This is helpful when you want the AI to build on earlier suggestions or explanations.
• Cursor rules. You can reference any Cursor rules you’ve set to guide the AI’s behavior. This ensures the AI follows specific guidelines or coding practices you’ve defined.
• Web. By default, Cursor doesn’t perform web searches. However, by using @web, you can instruct it to search the internet for updated information related to your project.

When you use @, Cursor retrieves the referenced content (file contents, code snippets, etc.) and adds it to the AI's context window as input tokens. The AI can now "see" and reference that specific information. It then responds with knowledge of the referenced content.

You’re not limited to tagging just one thing at a time. You can combine multiple references in a single context. For example, you can tag specific files, a function, related documentation, a Cursor rule, and a web search. This helps the AI work with a complete picture of your request, leading to more accurate responses.

Cursor rules 

Cursor rules are special instructions you can give to the Cursor AI assistant to control its behavior, limit its actions, or guide how it interacts with your codebase. These rule-based AI guardrails ensure the AI works within your preferences and project requirements.

There are three types of cursor rules.

• User (global) rules. Global rules apply throughout your projects. These are personal or team-wide preferences you want to follow, no matter what you’re working on. You could set a rule that tells the AI to always provide code snippets in TypeScript unless otherwise stated.
• Project rules. These rules are specific to each project or codebase you’re working on. You can set a rule that says: “All React components must be written as functional components using hooks in your project.”
• Memories. Memories are not written by you directly. They’re automatically created by Cursor based on your past conversations with the AI. This helps the Cursor remember important contexts or instructions you’ve given before. You can turn this on when you want the AI to use decisions from previous projects without repeating yourself.

Eke Kalu, Software Engineer at AltexSoft, shared his thoughts and experience with Cursor rules: "Cursor rules are guidelines and best practices that help steer the AI when working on specific parts of the codebase. I set up rules for API integration, page templates, testing, and so on. Of course, you don't want to make it too restrictive, or it might limit the model's output, but with the right balance, it helps reduce how much you need to modify the AI's output."

Background agents

Cursor’s regular agent mode still requires you to guide the AI step by step or approve actions. You often need to approve changes, guide the AI, or provide additional instructions as the task progresses. This helps you stay in control but isn’t ideal for repetitive or complex tasks you may want to automate.

This is where Cursor's background agents—only available in paid plans—come in. They are fully autonomous, remote agents designed to complete coding tasks independently in the background. Once you give a task to a background agent, it works on that task without your ongoing supervision.

For example, if you instruct the background agent to “Build a multi-step sign-up form,” the agent:

• Creates a new GitHub branch specifically for that task
• Works through your codebase to complete the task
• Makes any needed file changes, runs commands, and can search the web for resources
• Generates a pull request (PR) for its work
• Provides a summary of what it did, including changes, features, and details of the work

You can review the pull request, test locally, and merge the changes into your production branch if they meet your requirements. This way, your main codebase remains safe from any AI edits. You can also create multiple background agents and run them in parallel.

Cursor’s AI code editor pros

Cursor’s wide and rapid adoption is a testament to the growing demand for AI-driven software development. Here are some of its main advantages.

Deep context awareness

Cursor is context-aware and can provide relevant, project-specific code suggestions rather than random boilerplate code. This is possible because it indexes your codebase.

When you open a project in Cursor, it automatically scans and creates vector representations (embeddings) of the files in your codebase. This indexing allows Cursor’s AI to deliver more accurate suggestions, explanations, and search results tailored to your project.

As you continue working, Cursor keeps updating the index by automatically adding new files whenever they are created. You can also exclude specific files or folders from being indexed. This is helpful when you want to limit the AI’s focus to certain parts of the code or keep sensitive files out of its context.

You can even use the “@” tagging system to add extra context like documentation, web searches, files, GitHub branches, or previous chats, making the AI’s response more relevant and useful.

Easy to learn

Cursor, a VS Code fork, has an interface that’s familiar to developers who have used VS Code before. As someone with experience using VS Code, I found it easy to dive right into Cursor. Spinning up a new project and getting started with actual coding took little effort. The layout, tabs, file navigation, and terminal all worked just as expected, so there was no need to relearn the basics.

Even the AI features were easy to pick up. While I had to learn Cursor’s unique additions, the AI interface felt intuitive. It works a lot like ChatGPT—you type your prompt in plain language, and the AI responds in a chat panel. That familiarity made it much easier to experiment with the AI features without feeling overwhelmed.

Overall, the transition from VS Code to Cursor was smooth and getting started felt natural and quick.

Greater privacy control

Cursor provides a privacy mode feature that gives you more control over what data is shared with its remote servers or third-party model providers.

When this mode is enabled, neither party can use your codebase, prompts, or other usage data to train their products or AI models. Instead, all data is deleted immediately after each request is processed. This mode is ideal for developers working with proprietary or confidential projects.

For advanced features—like background agents or full context features—you must turn privacy mode off.

Vast extensions

Since it’s built on VS Code, Cursor gives you access to over 40,000 extensions from the VS Code marketplace. These include extensions for linting, debugging, theming, language support, version control, and more.

Cursor offers smooth migration for existing VS Code users. You don’t need to reinstall all your extensions or reconfigure your IDE setup from scratch. Cursor lets you import your VS Code settings and extensions with a single click, making the transition fast and easy.

Supports several LLMs

One of Cursor’s strongest selling points is its wide support for multiple large language models (LLMs). Cursor currently supports 26 LLMs, which places it among the top AI coding tools in terms of model variety. This flexibility is especially useful for developers who want to choose between different models based on accuracy, speed, or cost.

Cursor doesn’t just rely on a single provider. It supports a mix of LLMs from various providers, including its proprietary models and third-party models from OpenAI, Grok (xAI), Gemini (Google), DeepSeek, and Claude (Anthropic).

Another advantage is that Cursor is usually quick to integrate new LLMs once providers release them. For example, when Claude Sonnet 4 was released, Cursor supported it that same day, less than 30 minutes after release.

Great documentation

Cursor has solid documentation. The official docs cover everything from installation to managing context, handling integrations, Cursor rules, and more. There are also step-by-step guides, FAQs, and detailed explanations of each tool in the editor.

One thing that really stood out for me was the interactivity they added through the AI-powered docs chatbot. It helped me a lot. Instead of flipping through different pages and hoping to find the right section, I could just ask the chatbot a question—and since it's trained on everything Cursor-related, it would instantly give me the answer I needed.

Growing community of users

Cursor is one of the most popular AI-powered code editors on the market. It has a subreddit with 73,000 members, over 30,000 GitHub stars, and a Discord community with over 27,000 members. This growing community makes it easier for users to find help, discuss with the Cursor team, and stay informed about new features.

Cursor’s AI code editor cons

Cursor, like every tool, has its disadvantages. Let’s explore them.

Inconsistent code edits with some models

One of the recurring complaints from Cursor users, especially those using Gemini 2.5 Pro, is unreliable code editing. When users ask the model to make edits, it sometimes fails to apply the changes, requires multiple retries, or tells users to make the changes themselves.

In some cases, it claims to have completed a task when it actually hasn’t. For example, when in Ask mode, I prompted the AI to change the to-do app’s background color. Cursor claimed it applied the change I requested, even though it hadn’t.

The disconnect between what Cursor says and what actually happens can be frustrating. Switching models or restarting Cursor sometimes helps stop this behavior, but it's an ongoing problem for many users.

Frequent pricing changes

Cursor has recently implemented several pricing updates, which have frustrated some users. They say the pricing terms are confusing, and there is no clarity on how usage limits work or what they’re paying for.

The frequent pricing adjustments particularly affect users on annual plans, as they often find themselves locked into outdated pricing structures or features that change in the middle of their subscriptions.

Privacy trade-offs

Privacy mode comes with trade-offs. Some advanced features, like background agents, need to send your code to remote environments in order to work. This is disabled when privacy mode is active. If you need full automation with background agents, you’ll have to turn privacy mode off temporarily.

Balancing the trade-off between maximum privacy and full functionality can be tricky. On one hand, privacy mode helps protect sensitive or proprietary code and reduces compliance risks. On the other hand, turning it on limits access to some of Cursor’s most powerful features.

Performance issues with large codebases

Cursor’s file indexing and responsiveness can slow down when dealing with larger projects. While it performs well on smaller or medium-sized codebases, larger repositories cause delays during indexing or when generating responses. This can be frustrating for teams that rely heavily on Cursor to quickly iterate on big, enterprise-scale projects.

Sometimes struggles with large codebases and massive requests

Cursor sometimes struggles with accuracy during long, multi-turn conversations or when working with very large codebases. After several prompts or deep back-and-forth sessions, the AI can start producing incomplete, buggy, or unsuitable code.

Eke Kalu shared his experience with this behavior: “Cursor can be tricky. I once gave it a set of tests to make sure any code it generated would pass. After failing several times, instead of fixing the code to pass the tests, it rewrote the tests to match the flawed code. That’s the kind of thing you have to watch out for.”

Cursor tends to go off the rails and give poor output when it's handling tasks across multiple files. In such cases, you might have to refresh the session or restart Cursor to get it back on track. Breaking tasks into smaller, manageable chunks also helps.

Buggy software

Cursor isn't without bugs. Some issues are due to the rapid updates that break things. For example, users have reported that Cursor's LLMs became inaccessible after certain updates or the app would get stuck indefinitely on "generating" without producing any output.

There are also bugs that aren't related to updates. One recurring complaint is that Cursor sometimes ignores the rules users set. In one scenario, the AI responded: "I have your rules clearly stated right there in my context. I can read them. I understood them. But I still chose to follow some other behavior instead."

Issues like this can make it harder to rely on Cursor for consistent, predictable results, especially in projects where strict compliance with coding rules is critical.

Less robust than JetBrains IDEs

While Cursor’s VS Code-based interface is familiar to many developers, some backend developers who are used to JetBrains IDEs like IntelliJ and PyCharm may find the transition challenging.

This sentiment was shared by Glib Zhebrakov, Head of the Center of Engineering Excellence at AltexSoft, and Ihor Pavlenko, AltexSoft's Head of Operational Excellence. They mentioned that Cursor felt less robust than the more mature JetBrains IDEs they were used to.

One of the key issues is feature depth. JetBrains IDEs are positioned as robust, all-in-one platforms. They come with capabilities like

• advanced static code analysis,
• deep language-specific support,
• intelligent refactoring tools,
• deep code navigation,
• tight integration with testing frameworks,
• database tools,
• Docker support,
• Built-in HTTP client, and
• remote interpreters, all in a single environment.

Cursor, on the other hand, relies heavily on VS Code’s plugin ecosystem to replicate these functionalities. Users will have to manually install and configure said plugins, presuming they are available.

For teams used to an all-in-one, tightly integrated setup, Cursor’s lighter and more modular design can feel incomplete.

Struggles with legacy projects

While it performs well with prototypes and POCs, Cursor can struggle to keep up in legacy environments.

Cursor often has trouble managing context in these environments. As the codebase grows, it becomes harder for the tool to maintain accuracy and relevance in its responses.

Cursor may miss important dependencies, forget earlier parts of the conversation, or require repeated clarification from the user. This makes it less reliable for working with older or complex systems, where a deep understanding of the full project is necessary.

Cursor vs other AI coding tools

AI coding tools have become key in modern software development. Naturally, Cursor is just one of the many tools available in this space.

GitHub Copilot is the AI coding assistant developed by GitHub. Unlike full-fledged IDEs, Copilot isn’t a complete code editor. It’s an AI-powered autocomplete tool that’s available as a plugin in many popular editors. You can also access it via the web-based chatbot. However, this version can’t be used for coding tasks. Instead, it's mainly used to get insights regarding pull requests and repository-related issues.

Lovable is an AI-powered web application builder that lets you build complete apps using natural language prompts. It lives in the browser and has a chat-like interface similar to ChatGPT and other AI chatbots. Lovable specializes in creating web applications using a specific technology stack: React, TypeScript, Vite, Tailwind CSS, and Shadcn/UI.

Windsurf is another popular AI-powered code editor that blends development and AI assistance. It offers a plugin for IDEs like VS Code and JetBrains, but its core features are only available in the full Windsurf IDE.

Here’s a brief overview of how Cursor stacks up against these competitors.

Cost

Cursor offers a free plan that comes with limited requests and a two-week free trial for its Pro plan, which starts at $20 per month. GitHub Copilot is cheaper. It's free plan limits the LLMs you can access, and its Pro plan costs $10 per month.

Lovable is the most expensive option. It also has a free plan, but its monthly plan starts at $25. And even though it’s the highest-priced solution in the group, it’s not unlimited. You get 200 credits per month, and if you use them up, you’ll have to buy more credits. That makes it potentially a lot more expensive if you’re a heavy user, especially when compared to Cursor or Copilot, which both offer unlimited usage on their paid plans.

Like Cursor, Windsurf’s free plan has a two-week free trial. However, its paid plan starts at $15 per month. Like Lovable, it’s not unlimited either—you get 500 prompt credits each month, and you’ll need to buy extra credits once you use those credits.

Platform availability

In terms of where they run, Cursor is only available as an IDE. Windsurf is also an IDE but takes things further by also offering a plugin. GitHub Copilot is a plugin, but there’s the web-based chat, which we can use for GitHub-related operations like reviewing pull requests or checking repository details—it’s not built for actual coding.

Lovable takes a different route by being entirely web-based. Everything happens in the browser, so there’s nothing to install.

LLM model support

When it comes to the number of LLMs they support, Cursor currently leads the pack. It has one proprietary model, with 25 others from OpenAI, Gemini, Claude, xAI, and DeepSeek. GitHub Copilot offers 14 models from OpenAI, Claude, and Gemini. Windsurf supports 24 models, with 3 of them being in-house. The third-party models come from OpenAI, Claude, DeepSeek, and xAI. Lovable doesn't provide information on the models they support. Also, unlike with these other tools, Lovable's users can't switch between LLMs.

Key features

Cursor. One of Cursor's key features is the "auto" toggle in the chat, which, when turned on, lets Cursor automatically pick the best model for your task. Then it supports creating custom models that fit your workflow.

There’s also the background agent that handles coding tasks independently—we covered this feature earlier. Then there’s the 11 built-in tools Cursor’s provides that extend what the editor can do.

GitHub Copilot. One of GitHub Copilot’s key features is Agent Mode, which allows it to take on coding tasks independently. You can give it an assignment—like fixing a bug or writing a new function—and it handles the coding, testing, and even creating a pull request for you. Copilot offers a code review feature that helps catch bugs or suggests improvements before you push changes. And since it’s built by GitHub, it integrates smoothly with GitHub Actions, making it easier to test and iterate on issues assigned to Copilot.

Lovable. Lovable comes with native Supabase integration, which makes it easy to build full-stack applications. This integration means you can use a PostgreSQL database to store data, handle file storage, and set up user authentication. Lovable supports real-time collaboration among team members. Once teammates join your plan, you can see their cursors, get instant feedback on their changes, and make edits together. There’s also the Figma to Lovable integration, which simplifies handoffs between designers and developers.

As a web-based platform, Lovable supports live previews, meaning you can see changes in real time. It has a built-in editor that allows you to view and edit a project’s code. You can publish directly from Lovable—via its “Publish” button—and even set up custom domains.

Windsurf comes with a built-in Chromium browser, which lets you surf the web like any other browser. However, that’s not its main function. This browser is tightly integrated with Cascade, Windsurf’s coding agent. You can send logs, page content, and screenshots directly from the browser into Cascade.

The browser has a “select-element mode.” With this, you can click on specific UI elements on a web page—similar to selecting layers in Figma—and Windsurf will automatically send the element’s context and a screenshot to Cascade.

From there, you can ask questions, request edits, or make improvements based on that exact element, all without the usual back-and-forth of copying and pasting between tabs.

Windsurf’s “Workflows” feature lets you set up a series of repeatable steps to help automate common development tasks. You can create workflows for things like deploying apps, running security scans, addressing pull request comments, or even automating dependency updates.

Windsurf also provides five tools—Search, Analyze, Web Search, MCP, and Terminal—that extend its functionality. It also has a “Commit Messages” feature lets you generate commit messages with one click. It scans your staged code changes and suggests a message that summarizes what was changed.

Getting started with Cursor AI code editor

Now that we've explored Cursor's strengths and weaknesses let's look at some helpful resources to get you started.

Documentation. Cursor’s documentation is the best place to begin. It includes an installation guide, an explanation of its editor’s features, and more. The documentation also covers how to migrate IDE settings if you’re switching from VS Code.

Community. You can engage with the cursor team and members of its user base via forums, subreddits, and Discord. This is a great place to ask questions, share feedback, and learn from other developers who use Cursor daily.

Online courses. To learn by watching, check out video tutorials and courses on YouTube, Udemy, Coursera, and similar platforms. Many content creators have published practical guides showing how to write code and build apps with Cursor.

GitHub repos. They’re also community-created repos like awesome-cursorrules, which contain a collection of custom rules you can use when working with Cursor.