My New Favorite IDE: Cursor

In the world of AI-powered development tools, one question is currently a hot topic on tech forums and subreddits:

AI-powered IDEs

Like many skeptical software engineers, I initially brushed off Cursor IDE as just another AI coding tool.

Introduced to it by a colleague in October 2023, but it just didn't stick with me. After more than a year, a member of my team mentioned it a few months ago and I decided to give it a new chance.

A few months of consistent use across personal and professional projects, and my perspective has changed significantly so I decided to write something about it.

This insight is primarily aimed at experienced software engineers who are comfortable navigating complex codebases, working in JavaScript/TypeScript ecosystems, and crafting sophisticated web applications. It's not recommended for coding novices seeking AI hand-holding or software engineers primarily focused on generating massive amounts of code.

My core philosophy with AI coding tools isn't about generating massive code volumes.

Instead, I'm looking for an intelligent assistant that handles boilerplate boring work, accelerates repetitive coding tasks, and allows me to focus on business logic, project architecture, problem-solving, and code quality.

Cursor IDE isn't a magic wand, although it shows promise in specific scenarios. It can shine in the fast prototype development, reducing cognitive load for repetitive coding blocks. It provides context-aware code generation and offers intelligent refactoring suggestions.

This perspective of mine comes with complete transparency: this isn't a sponsored review or product endorsement. These are genuine, unfiltered observations from a working software engineer who's road-tested the tool in real-world scenarios.

Cursor - AI powered IDE

Cursor IDE represents an innovative fork of Visual Studio Code, integrating Large Language Model (LLM) capabilities into its core user interface. So if you are familiar with VS Code UI, you can barely tell the difference when using Cursor IDE.

As a tool with both free and subscription tiers, Cursor wants to transform how software engineers interact with their code editing environment. It changes the traditional coding experience by introducing AI-driven features beyond standard code completion.

These features are strategically designed to reduce cognitive load and accelerate development processes. With these tools, you don't need to switch to a browser, type into ChatGPT, copy-paste code, etc.

Let me summarize its key features in straightforward terms:

Tab Completion (Subscribers Only)

The tab completion feature stands out as a subscriber-exclusive capability. Unlike traditional autocomplete, this isn't just about suggesting the next lines of code.

It's an intelligent system that predicts code snippets and helps navigate recommended actions, all triggered by a simple tab press. It's like having an experienced software engineer quietly suggesting your next logical coding step.

Inline Editing

Available to all users, inline editing provides a chat-based interface for making precise code modifications. It's like selecting a block of code and having an AI assistant suggest improvements or rewrites, complete with a clear different view.

Chat Sidebar

The chat sidebar improves inline editing by offering a more comprehensive editing environment. This feature allows software engineers to engage in more extended discussions about code, generate suggestions across multiple files, and explore more complex refactoring scenarios.

It's like having a pair programming session with an AI to understand your entire project's context. You can tag specific files, or the whole codebase and ask questions.

Composer

Composer is perhaps the most powerful feature, a specialized chat interface designed for large-scale code refactoring. It can generate diffs across multiple files, allowing software engineers to preview and approve changes systematically.

I will explain how I use these features.

Tab Completion

Unlike other AI coding tools that rely primarily on conversational interfaces, Cursor's tab completion feels like a natural extension of a programmer's workflow.

It's smart enough to understand context and anticipate your next editing moves.

Imagine writing a chunk of code and then effortlessly propagating changes throughout your file with just a few Tab key presses.

One of the most powerful use cases is code refactoring so let's break down a practical example: Say you're working on a codebase that uses some translation strings. Traditionally, this would be a tedious, error-prone manual process.

With Cursor IDE, you can:

1. Copy a single instance of translation string
2. Go to the localization JSON file and hit Tab to add those translation strings
3. Press Tab repeatedly to automatically update related text across the entire component file

The tool's smart assistance capabilities are remarkably comprehensive. It can independently detect potential bugs, automatically suggest necessary imports added in React, and intelligently handle formatting tasks like escaping strings.

Perhaps most impressively, it can generate entire function bodies based on just a function signature and optional documentation.

Performance is a standout feature that cannot be overstated. Suggestions appear instantaneously, with zero perceivable lag.

For software engineers who value speed and workflow efficiency, this near-instantaneous responsiveness is crucial. The difference between waiting a few seconds versus getting an immediate suggestion can significantly impact coding productivity and mental flow.

However, the tool isn't without its limitations. I noticed 2 challenges from practical use.

First, suggestion visibility can be problematic - sometimes suggestions are missed if typing occurs too quickly, and once disappeared, they cannot be retrieved without additional effort.

Second, and more subtly, the tool occasionally proposes incorrect completions or quietly applies previously dismissed suggestions when a different completion is accepted.

These issues are infrequent enough that they don't fundamentally undermine the overall productivity boost. You can compare it to working with a highly capable junior software engineer who is mostly brilliant but occasionally requires gentle supervision.

Inline editing, Chat and Composer

Inline editing provides a quick, targeted approach to code modifications. By selecting a code snippet and pressing Ctrl-K or Cmd-K, users can propose changes directly within the context of their existing code.

The tool generates a diff view, allowing immediate visualization of proposed modifications before acceptance. This feature proves especially useful for implementing small code segments or executing minor refactoring tasks within a specific function.

The chat sidebar expands the conversational space for more comprehensive interactions. Activated with Ctrl-L or Cmd-L, it offers broader space for multi-turn conversations with the AI.

One notable characteristic of current language models is their tendency to generate code immediately rather than seeking clarification when instructions might be ambiguous.

The sidebar includes an Apply button that creates a diff in the selected file, making it valuable for more extensive single-file refactoring or generating entirely new files based on existing code.

The Composer feature represents Cursor's most advanced editing interface, specifically engineered for complex, cross-file refactoring scenarios.

While I don't use this feature often, it provides a structured workflow for reviewing and applying modifications across multiple files sequentially.

The underlying technology uses Claude 3.5 Sonnet's sophisticated language understanding, translating natural language instructions into precise code modifications.

Users can change these models, you can use the GPT model if you want.

.cursorrules file

Software engineers can use this configuration file to communicate essential project details such as coding standards, common package dependencies, and specific documentation practices.

This becomes particularly valuable when working with unique or proprietary libraries that may not be immediately familiar to an AI system.

The current implementation does have some limitations. Workspace-level configuration means that mono repo projects with multiple languages or diverse coding styles might find the single-file approach restrictive.

The official documentation states the .cursorrules file only influences chat-based interactions.

Here you have a repo with some great .cursorrules files.

How my workflow changed

The first thing I've noticed is a significant increase in laziness.

When faced with a challenge, I instinctively turn to Cursor IDE, relying on its suggestions. And when they fail, I'm left to pick up the pieces myself.

While productivity has undoubtedly soared, it's come at a cost. Learning new concepts is quicker, except when the Cursor IDE generates incorrect or misleading information, which happens surprisingly often, especially for niche topics.

Cursor IDE is a powerful tool, but it's not infallible. It's easy to get caught in the trap of relying too heavily on it, sacrificing long-term benefits for short-term gains.

I've accomplished a great deal of work, thanks in large part to AI. But as a result, I've noticed a stagnation in my coding skills.

Here are my key observations:

1. Increased reliance on AI for problem-solving and research.
2. Significant boost in productivity.
3. Enhanced research capabilities.
4. Occasional mislearning due to AI inaccuracies.
5. AI's limitations in replacing human jobs are evidenced by its inconsistent responses.

The initial excitement surrounding AI seems to be decreasing. We're starting to realize that, for now, AI is essentially a sophisticated calculator with chatbot capabilities. At least, that's my take on it.

That's also my feeling when using Cursor IDE.

I'm unsure if I will use Cursor IDE in 5 years, or move to another tool.

But right now for me, it's the best coding assistant you can get. If you want to explore how this tool might be of value, I encourage you to do it.

The essence remains the same: it's not about coding faster, but coding smarter - with more precision, less unnecessary complexity, and greater adaptability to AI tools.