Enhancing Software Development with AI Tools: A Practical Look at Cursor IDE

In this article, Anton Trofimov, Senior Software Developer at ELEKS, shares the hands-on experience of using Cursor IDE for one of our customer's projects. He also provides an overview of the tool and a brief list of features he uses the most often.

What is Cursor IDE?

Cursor IDE is a code editor based on Visual Studio Code (VSCode), with a fresh UI and enhanced AI capabilities. It stays fully compatible with the VSCode ecosystem, so teams can adopt AI-assisted development without losing their existing extensions, settings, or workflows. Simply import everything from VSCode via File → Preferences → Cursor Settings → VSCode Import.

Cursor offers both free and paid plans. The free version covers basic functionality but may have usage limits or slower performance. Current pricing details are available on Cursor's website.

This evaluation is based on our experience with pro-plan functionality as of February 2025.

Getting started with Cursor IDE

Begin by reviewing the official documentation, which provides a comprehensive overview of available features and configuration options. It takes about an hour to read the instructions, which are short and detailed. It's a great way to learn about what the platform can do. Now, let's look at the first two configuration steps.

1. Project configuration (.cursorrules)

A critical first step when adopting Cursor IDE is adding a .cursorrules file to your project root. This human-language configuration helps the AI understand your project context and provide more relevant suggestions. The file can specify:

• Project structure details
• Code style preferences
• Autocomplete suggestions

You can find pre-built .cursorrules templates across several community resources, like GitHub, Cursor Rules, Cursor 101, etc. You can find general rules applicable to your specific stack or get inspiration to write your own. We recommend adjusting them to your requirements.

2. Essential settings customisation

Go to File → Preference → Cursor Settings. While there are many settings, we'll focus on the crucial ones: privacy mode and model configurations.

Privacy mode

Recommended setting: enabled. It prevents AI from processing sensitive code base data.

Model selection

For our evaluation, we used the Claude 3.5 Sonnet 20241022. While disabled by default, this model provided an optimal balance of quality and response time.

The newer model Claude 3.7 was added in March 2025, but we still use the 3.5 model, which often provides better results for our needs.

API configuration

Cursor supports OpenAI-compatible APIs through the "Override OpenAI Base URL" setting. It's compatible with providers like openrouter, togetherai, or any other OpenAI-compatible API provider.

Custom API providers offer:

• Pros: access to cost-effective APIs, use of unsupported models, and potential integration with local LLMs.
• Cons: some Cursor features might not work (e.g., terminal command instructions).

Core Cursor's features that accelerate development

Cursor comes packed with features designed to streamline the coding process and enhance coding efficiency. Let's dive deeper into the features we find worth using based on our hands-on experience.

Chat

The chat interface, opened with Ctrl+L (or Command+L on Mac), is your main way to interact with a single file. You may select a block of code and use this shortcut to add it to the chat or simply paste, drag-and-drop files, or even images. You can also use @ Syntax to quickly add multiple elements (more on that below).

In the bottom left corner, you'll find the model selector. For coding, we recommend Claude models (like Claude 3.5 Sonnet 20241022). For text editing, o3-mini might work better, though Claude could also be an option. The best approach? Experiment and see what works for you.

Let's imagine you've selected file "utils/helpers.ts" and you want to perform the "getFullName" function. You can select it from a file and use hotkeys for a chat or type @→Code, then search for the function. It will automatically reference it in the chat.

Prompt:

Please create unit tests for getFullName function.  
Name it getFullName.test.ts, put it in the same folder with helpers.ts

It can generate unit tests for any function you choose. We've used it a few times to work with random React components we pulled straight from Google search results, and it's been a game-changer.

Prompt:

import { people } from './data.js';
import { getImageUrl } from './utils.js';

export default function List() {
const chemists = people.filter(person =>
person.profession === 'chemist'
);
const listItems = chemists.map(person =>
<li>
<img
src={getImageUrl(person)}
alt={person.name}
/>
<p>
<b>{person.name}:</b>
{' ' + person.profession + ' '}
known for {person.accomplishment}
</p>
</li>
);
return <ul>{listItems}</ul>;
}

Please convert to Svelte and add missing referenced functions/mocked data.

It should generate something like this and suggest creating new files with mocked data and utils (we're not adding them here since they take up a lot of space and aren't necessary).

Code sample:

<script>  
    import { people } from './data.js';  
    import { getImageUrl } from './utils.js';  
    const chemists = people.filter(person =>  
        person.profession === 'chemist'  
    );  
</script>  
<ul>  
    {#each chemists as person}  
<li>  
<img  
                src={getImageUrl(person)}  
                alt={person.name}  
            />  
<p>  
<b>{person.name}:</b>  
                {' ' + person.profession + ' '}  
                known for {person.accomplishment}  
</p>  
</li>  
    {/each}  
</ul>

We've tried converting React to Svelte Kit, C# to TypeScript and C to TypeScript. The AI can generate code across multiple languages, with React to Svelte Kit working perfectly, while C# to TypeScript works well enough. The C to TypeScript, on the other hand, didn't work as well as it could have, and it took a lot of time and additional engineering work to get good results (based on our implementation experience).

Code instructions

It's a quick in-place helper (opened with Ctrl+K or Command+K on Mac) for making small changes or adding new blocks. If your task is more complex, you may want to use chat instead.

Code sample:

for(var i=10; i<3; i++){  
    console.log(i);  
}

Select→hotkeys→prompt.

Prompt:

Please fix

Output:

for(let i=0; i<10; i++){  
    console.log(i);  
}

You don't even need to write complicated prompts for tasks like this. If the changes don't work as expected, you can reject them and edit them again.

Composer

Please note that after the March updates, this functionality has been merged into chat, and the Ctrl+I combination is used to run code with the agent by default (while Ctrl+L runs "ask" mode).

With this feature (Ctrl+I or Command+I on Mac), you can edit or create multiple files at the same time. You can even set up an entire project in one go, creating all the necessary files and suggesting terminal commands.

This is particularly useful when you need to write code that implements complex business logic, and is as helpful when working on the frontend and backend for a new feature. You may run something like this.

Prompt:

I want to create an authorisation workflow.  
Please use @src/frontend/routes/auth and @src/backend/routes/auth folders to create all required files.  
Please add validation rules for all fields.  

Required fields: email, password, checkbox "I agree to the terms and conditions", checkbox "Remember me."  

Please use a Sequelize model called User from @src/backend/models/User.ts."

Autocomplete

Not much to say here, but it's undeniably useful for efficient code generation. While it can do things you don't expect, it significantly speeds up development in most cases.

TDD now can be considered to stand for "Tab Driven Development"–the modern approach where you simply hit Tab whenever you see an autocompletion or suggestion you like, and voilà, instant code generated! 😉

In short, making use of this feature is very helpful.

@ Syntax

@ symbol is basically a shortcut, which allows you to open context menu with a bunch of handy features.

@Files/@Folders

This feature lets you easily add files to the chat context using the header. Select the files you want, and they'll be added to the context.

With this, you can do some pretty cool things! For example, you can select a DTO and ask the Cursor to generate all its methods. Or, you can pick a specific function from one file and have the Cursor use it with the right parameters in another file. You can even generate unit tests. The possibilities are endless; get creative and experiment with the feature.

The same functionality works with folders, too.

@Code

This lets you search and add code blocks to the chat, along with other things like documentation, text, and more.

@Docs

You can provide URLs for required pages or even entire docs. The Cursor will scrape them and use them as part of the codebase. When you first use @ Docs, you may need to click the "Add new doc" button. After that, you can use it as part of the prompt, and it will show up in the list of suggestions when you type @ Docs.

Prompt:

Please update the Syntax of @src/frontend/routes/auth/page.svelte to use Svelte 5 Syntax (runes, etc.)  
Please use @SvelteKitDocs for documentation.

@Codebase

Please note that after the March updates, this feature is not available in the agent mode.

This feature uses a more streamlined model to initially index your codebase, then perform search/rank/retrieval operations to deliver optimal results. For a shortcut, you may use CTRL+Enter or Command+Enter.

Why is it useful? Well, for us, having a natural-language search across our codebase was a game-changer.

Prompt:

@Codebase  
Please find all frontend files related to processing payments and list them there.

But it's not the only use case for this feature. You may also use it when manually adding all the files referenced in a 1,000-line legacy function feels too time-consuming.

@Web

Please note that after the March updates, the agent will search the internet by default. You can still use it in ask mode to ensure you receive accurate information.

This feature is your best option when you're unsure what you're searching for or need the latest documents. It's also useful when the model you're using is outdated.

Prompt:

Hello!  
Please write an example Svelte 5 page to display a mocked API response using runes.  
 
@Web

There are also a lot of other features that we haven't mentioned here yet, like @ Notepads, @ Recent Changes, etc. Even if we didn't use them, they might be helpful to you.

Terminal feature

Please note that after the March updates, the agent mode of chat may generate and execute commands as part of a prompt response. By the way, this feature is still pretty useful for the cases described.

You may use Command Instructions to generate terminal commands or copy errors (the Cursor will highlight them for you) and ask to fix them in chat/composer.

Prompt:

Please find out what locks port 3005 and terminate it. (PowerShell)

It will produce something like that:

Get-Process -Id (Get-NetTCPConnection -LocalPort 3005).OwningProcess | Stop-Process -Force

This feature is handy when dealing with a badly configured dev mode that frequently gets stuck, preventing new ports from opening. It's also useful when multiple terminals are open and you're unsure why your app is already running.

Conclusions

There are a few important things to keep in mind when using AI and Cursor. Code privacy should always come first, even if a company says it will protect data. AI can be very helpful in the coding environment, but it's not perfect; always check the code it generates to make sure it's correct and reliable.

Remember that being good at AI doesn't make you less good at what you do. Stay involved in the process instead of putting all of your trust in AI. Taking breaks from AI can help you keep your eye on the big picture of the job. Also, AI might have trouble with niche jobs or very specific technical problems, so be ready to help out when you need to.

In the end, AI is a useful tool that should be used with caution and moderation.

Secure your development environment