01 - Cursor IDE: The Complete Developer Guide
Software development is undergoing its most significant transformation in decades. After years of incremental improvements to syntax highlighting, autocomplete, and integrated debugging, we have entered a fundamentally new era: AI-native IDEs, where artificial intelligence is not a bolted-on plugin but the very core of the development experience.
At the center of this revolution is Cursor, an editor that has surpassed one million daily active users and reached a $29.3 billion valuation by the end of 2025. With over $1 billion in annual recurring revenue (ARR) achieved in less than 24 months from launch, Cursor has become the fastest-scaling SaaS product in software history.
In this comprehensive guide, we will explore every aspect of Cursor: from installation and setup to core features, advanced capabilities like parallel agents introduced with Cursor 2.0, and practical strategies for integrating AI into your daily workflow. Whether you are a curious developer or a seasoned professional ready to level up, this guide will give you everything you need to get started productively.
What You Will Learn
- What Cursor IDE is and why it represents a paradigm shift in software development
- The concrete differences between Cursor and VS Code, including extension compatibility
- How to install and configure Cursor from scratch or migrate from VS Code
- Core features: Tab autocomplete, Cmd+K inline editing, Chat panel, and Composer
- Agent Mode and Composer Mode: how to delegate complex tasks to the AI
- Codebase indexing and the context system with @codebase, @files, @docs
- Cursor 2.0: up to 8 parallel agents with git worktrees
- Plans, pricing, and how to choose the right configuration for your needs
Series Overview: Cursor IDE and AI-Native Development
| # | Article | Focus |
|---|---|---|
| 1 | You are here - Complete Cursor IDE Guide | Full overview |
| 2 | Cursor Rules | Custom AI configuration |
| 3 | Agent Mode | Advanced automation |
| 4 | Plan Mode | AI-assisted planning |
| 5 | Hooks and MCP | Extensibility and integrations |
| 6 | Professional Workflows | Production best practices |
What Is Cursor and Why It Is Reshaping Development
Cursor is an AI-native code editor built by Anysphere, a startup founded in 2022 by a group of MIT researchers. Unlike tools such as GitHub Copilot that add AI capabilities to existing editors through extensions, Cursor was built from the ground up with artificial intelligence woven into its core. Every interaction, from autocomplete to full-file generation, is designed to be powered by frontier language models.
The idea behind it is simple yet powerful: AI should not be an external tool you consult, but an ever-present collaborator that understands your project, your coding style, and your intent. Cursor achieves this through three key innovations:
- Semantic codebase indexing - Cursor analyzes and indexes every file in your project using vector embeddings, allowing the AI to understand relationships between components, dependencies, and patterns used throughout the codebase
- Intelligent multi-file context - Unlike a generic chatbot, Cursor can "see" dozens of files simultaneously, understand the interconnections, and propose coherent changes across the entire project
- Deep editor integration - The AI can directly modify files, execute terminal commands, install dependencies, and even run tests, all without leaving the editor
Cursor by the Numbers (End of 2025)
| Metric | Value |
|---|---|
| Daily active users | 1M+ |
| Annual Recurring Revenue (ARR) | $1.2B |
| Valuation | $29.3B (Series D, Nov 2025) |
| Year-over-year ARR growth | +1,100% |
| Fortune 500 adoption | 50%+ of companies |
| AI IDE market share | ~18% (up from 3% in 2024) |
These numbers tell a clear story: Cursor is not an academic experiment or a niche tool. It has become a production-grade instrument adopted by companies like Nvidia, Uber, Adobe, and more than half of the Fortune 500. The 1,100% year-over-year growth demonstrates that developers are actively embracing the AI-native paradigm.
Cursor vs VS Code: What Actually Changes
One of the first questions developers ask is: "Why not just use VS Code with GitHub Copilot?". It is a fair question. Cursor is a fork of Visual Studio Code, meaning it shares the same codebase, interface, and most of the same functionality. But the differences are substantial.
Design Philosophy
VS Code follows an extension-driven approach: the editor is a neutral platform, and AI features are added through extensions (Copilot, Codeium, etc.). Cursor takes an AI-first approach: artificial intelligence is embedded in the editor's core and influences every aspect of the experience, from autocomplete to the user interface.
This architectural difference has practical consequences. In VS Code, Copilot can suggest code line by line but lacks deep access to the entire codebase. In Cursor, the AI indexes every file, understands relationships between modules, and can propose changes across multiple files simultaneously. It is the difference between having an assistant that reads the current line and a collaborator that knows the entire project.
Extension Compatibility
As a VS Code fork, Cursor is compatible with the vast majority of VS Code extensions. You can install and use without issues extensions such as:
- ESLint, Prettier - Linting and formatting
- GitLens - Advanced git information
- Docker - Container management
- Thunder Client - REST API testing
- Language extensions - Python, Go, Rust, Java, and all others
There are some exceptions, however. Extensions that require Microsoft account access (like Live Share) or have very deep integrations with VS Code's specific infrastructure may present compatibility issues. As a general rule, if an extension works with Open VSX (the open-source marketplace), it will work with Cursor as well.
Quick Comparison: Cursor vs VS Code + Copilot
| Feature | Cursor | VS Code + Copilot |
|---|---|---|
| AI completion | Predictive multi-line + Tab | Single/multi-line |
| Codebase indexing | Built-in, automatic | Limited to current file |
| AI inline editing | Cmd+K with project context | Copilot Chat (limited context) |
| Multi-file generation | Native Composer Mode | Not supported |
| Autonomous agent | Agent Mode + Background Agents | Copilot Edits (basic) |
| Parallel agents | Up to 8 with git worktrees | Not supported |
| Available models | GPT-4o, Claude, Composer, custom | OpenAI/Microsoft models only |
| VS Code extensions | Compatible (nearly all) | Full marketplace |
| Cost (AI plan) | $20/month (Pro) | $10/month (Copilot Individual) |
Installation and Setup
Getting started with Cursor is straightforward. The editor is available for macOS, Windows, and Linux, and the installation takes less than five minutes, even if you are migrating from VS Code.
Download and Installation
- Go to cursor.com and click the download button for your operating system
- Run the installer (DMG on macOS, EXE on Windows, AppImage/deb on Linux)
- On first launch, Cursor asks you to create an account or sign in with Google/GitHub
- Select the Free plan (includes 2,000 completions and 50 slow premium requests per month)
Migrating from VS Code
If you already use VS Code, Cursor offers an automatic migration feature on first launch. The import includes:
- Extensions - All installed extensions are imported automatically
- Settings - Your
settings.jsonfile is copied over - Keybindings - Custom keyboard shortcuts are preserved
- Themes and fonts - Visual customizations are maintained
- Snippets - Your custom snippets are imported
Practical Tip
You do not need to uninstall VS Code. Many developers keep both editors installed, using Cursor for daily AI-powered development and VS Code for specific tasks that require incompatible extensions or Live Share sessions.
Recommended Initial Configuration
After installation, there are several settings I recommend configuring immediately to get the most out of the experience:
Cursor Settings > Features:
1. Autocomplete:
- Enable "Enable Autocomplete" (active by default)
- Set delay to "Fast" for instant completions
2. Chat:
- Select your preferred model (Claude Sonnet 4 recommended)
- Enable "Always search the web" for up-to-date context
3. Codebase Indexing:
- Verify indexing is complete (green bar)
- Configure .cursorignore to exclude node_modules, dist, build
4. Privacy:
- Choose "Privacy Mode" if working on proprietary code
- With Privacy Mode, your code is not used for training
Core Features of Cursor
Cursor stands out through three fundamental features that cover every type of code interaction: Tab autocomplete for fluid writing, Cmd+K for surgical editing, and Chat panel for in-depth conversations.
Tab Autocomplete: Predictive Completion
Cursor's Tab completion is radically different from traditional IntelliSense or even GitHub Copilot. It uses a proprietary low-latency model that does not merely complete the current line but predicts your next actions.
As you write code, Cursor analyzes the surrounding context, recent changes, and the pattern you are following to propose multi-line completions. If you are building a for loop and have just written the first case, Tab can suggest the entire next block. If you describe what you want to do in natural language (for example, through a comment), Cursor generates the corresponding code.
A particularly useful aspect is partial accept: by pressing Cmd+Right Arrow
(or Ctrl+Right Arrow on Linux/Windows), you can accept the suggestion word by word
instead of accepting the entire block with Tab. This gives you granular control over AI proposals.
Cmd+K: Surgical Inline Editing
Cmd+K (or Ctrl+K on Linux/Windows) is the tool for fast, targeted
editing. Select a block of code, press Cmd+K, and describe in natural language what you want
to do. Cursor generates an inline diff that you can accept, reject, or modify.
Typical use cases:
- "Add error handling to this function" - Cursor wraps the code in try/catch with logging
- "Convert to async/await" - Transforms callbacks or Promise chains into async code
- "Optimize this query" - Rewrites SQL or database queries for better performance
- "Add TypeScript types" - Adds type annotations to untyped JavaScript code
- "Explain and comment this code" - Adds explanatory comments to the selected code
The power of Cmd+K lies in its context awareness: it does not work only on the selection but takes into account the entire file, imports, defined types, and project conventions.
Chat Panel (Cmd+L): Conversations with the AI
The Chat panel, accessible via Cmd+L (or Ctrl+L), opens an
interactive conversation with the AI in the side panel. Unlike a generic chatbot, Cursor's
Chat has direct access to your codebase and can:
- Answer project questions - "How does the authentication system work?"
- Analyze code - "Are there potential memory leaks in this service?"
- Suggest refactoring - "How can I improve the structure of this module?"
- Generate tests - "Write unit tests for this function covering edge cases"
- Apply changes - Code generated in chat can be applied directly to the file with a single click
Essential Cursor Shortcuts
| Shortcut (macOS) | Shortcut (Win/Linux) | Function |
|---|---|---|
| Tab | Tab | Accept autocomplete suggestion |
| Cmd+Right Arrow | Ctrl+Right Arrow | Accept word by word |
| Esc | Esc | Dismiss suggestion |
| Cmd+K | Ctrl+K | Inline AI edit |
| Cmd+L | Ctrl+L | Open Chat panel |
| Cmd+I | Ctrl+I | Open Composer |
| Cmd+. | Ctrl+. | Toggle Agent Mode in Composer |
| Cmd+/ | Ctrl+/ | Switch AI model |
| Cmd+N | Ctrl+N | New Composer session |
Composer Mode: Multi-File Generation
While Tab autocomplete and Cmd+K operate at the single-file level, the Composer
(accessible with Cmd+I) is the tool designed for tasks that span
multiple files simultaneously. This is where Cursor truly demonstrates its
superiority over traditional AI coding tools.
The Composer presents a chat-like interface with a fundamental difference: it can create, modify, and delete multiple files in a single operation. Changes are presented as a series of diffs that you can review and selectively apply.
When to Use the Composer
- Feature scaffolding - "Create a new authentication module with login, registration, and password reset"
- Cross-file refactoring - "Move this logic from the component to a dedicated service and update all imports"
- Test generation - "Generate unit tests for all public methods of UserService"
- Cross-cutting feature addition - "Add structured logging to all API controllers"
- Pattern conversion - "Convert all class-based components to functional components with hooks"
Practical Example with the Composer
Imagine you want to create a complete CRUD service for a "Product" entity in an Angular project. An effective Composer prompt could be:
Create an Angular service for managing Products with these specifications:
- Product interface with id, name, description, price, category
- ProductService with CRUD methods using HttpClient
- ProductStore using Angular Signals for state management
- Complete error handling with retry and fallback
- Unit tests for the service covering edge cases
The Composer will generate multiple files: the interface product.model.ts, the
service product.service.ts, the store product.store.ts, and the
test file product.service.spec.ts. Each file will be consistent with the others
and will respect the project's conventions thanks to codebase indexing.
Composer Best Practices
- Be specific: Vague prompts produce vague results. Specify conventions, patterns, and technologies to use
- Always review: Never apply changes blindly. Read every diff before confirming it
- Break down complex tasks: Instead of asking "Create a complete e-commerce site", divide into atomic tasks: first models, then services, then components
- Use context: Add reference files to the Composer with @files to give the AI examples of your coding style
Agent Mode: The AI That Acts Autonomously
Agent Mode represents the most advanced level of AI interaction in Cursor.
Activated with Cmd+. inside the Composer, Agent Mode transforms the AI from a
passive suggester into an autonomous agent capable of executing concrete
actions on your codebase.
In Agent Mode, Cursor can:
- Read and write files - Create, modify, and delete project files
- Execute terminal commands - Install dependencies, run builds, launch tests
- Navigate the codebase - Search files, analyze imports and dependencies
- Iterate on results - If a test fails, the agent analyzes the error and fixes the code
- Use external tools - Interact with browsers, databases, and other services through MCP
A Concrete Example
Suppose you tell the agent: "Add form validation with custom error messages to the registration component". Agent Mode will execute these steps autonomously:
- Search for the registration component in the project
- Analyze the existing form and its fields
- Add appropriate Angular validators (required, email, minLength, etc.)
- Create custom error messages in the template
- Update styles to highlight fields with errors
- Run the build to verify there are no compilation errors
- If the build fails, automatically fix the issues found
Agent Mode vs Composer: When to Use Which
| Characteristic | Composer (Normal) | Agent Mode |
|---|---|---|
| Generates code | Yes | Yes |
| Modifies multiple files | Yes | Yes |
| Executes terminal commands | No | Yes |
| Installs dependencies | No | Yes |
| Autonomous iterative cycle | No | Yes |
| Checks build/tests | No | Yes |
| Requires supervision | Moderate | Minimal |
| Ideal for | Known, specific changes | Exploratory, complex tasks |
Agent Mode Safety
Agent Mode requires careful attention. The agent can execute terminal commands, which means it can potentially perform destructive operations. Cursor implements a confirmation system: before executing a terminal command, you are asked to approve it. Do not enable YOLO mode (automatic execution without confirmation) unless you are working in an isolated sandbox environment.
Available AI Models: How to Choose
One of Cursor's advantages is the ability to choose among different AI models. This flexibility
allows you to balance speed, quality, and cost based on the specific task. You can switch
models on the fly with Cmd+/ (or Ctrl+/).
Main Models
Model Selection Guide
| Model | Strengths | Best For |
|---|---|---|
| Claude Sonnet 4 | Excellent code understanding, complex instructions, deep reasoning | Agent Mode, complex refactoring, architecture |
| GPT-4o | Fast, versatile, good speed-to-quality ratio | Daily chat, quick questions, code review |
| Composer 1 | Cursor's proprietary model, 4x faster, coding-optimized | Rapid completion, multi-file editing, high-frequency workflows |
| Cursor Tab | Proprietary autocomplete model, ultra-low latency | Real-time Tab completion while typing |
| Claude Opus 4 | Maximum reasoning capability, deepest analysis | Architectural decisions, complex debugging, security analysis |
My recommendation is to start with Claude Sonnet 4 as the default model for Composer and Agent Mode: it offers the best balance between code quality, context understanding, and response speed. For Tab autocomplete, Cursor automatically uses its optimized proprietary model.
Composer 1: Cursor's Proprietary Model
With the launch of Cursor 2.0, Anysphere introduced Composer 1, its first internally built language model. It is a Mixture-of-Experts (MoE) model trained with reinforcement learning in cloud sandbox environments. Anysphere claims it is 4 times faster than models of similar intelligence, and it has been specifically optimized for multi-step software engineering tasks and agentic collaboration.
Codebase Indexing: How Cursor Understands Your Project
The true power of Cursor emerges from its codebase indexing system. When you open a project, Cursor automatically analyzes every file, splits it into semantically meaningful chunks, generates vector embeddings, and stores them in a vector database for fast semantic search.
How Indexing Works
- Scanning - Cursor scans the project folder and computes a Merkle tree of hashes for all valid files
- Chunking - Each file is split into semantically coherent chunks (functions, classes, logical blocks)
- Embedding - Chunks are transformed into numerical vectors through an embedding model
- Storage - Embeddings are stored in a remote vector database for fast retrieval
- Query - When you ask something, Cursor retrieves the most relevant chunks using cosine similarity
The Context System: @mentions
Cursor provides a powerful contextual reference system you can use in Chat and Composer to guide the AI toward relevant information:
Available @mention Commands
| Command | What It Does | Usage Example |
|---|---|---|
| @codebase | Searches the entire indexed codebase | "@codebase how do we handle authentication?" |
| @files | Includes specific files in context | "@files user.service.ts - add a cache method" |
| @docs | Searches indexed external documentation | "@docs Angular - how do Signals work?" |
| @web | Searches for up-to-date information online | "@web what are the new features in TypeScript 5.9?" |
| @git | Includes commits, diffs, or pull requests | "@git last 5 commits - any breaking changes?" |
| @definitions | Includes symbol definitions (types, interfaces) | "@definitions User - show where this type is used" |
The .cursorignore File
Just as .gitignore excludes files from version control, the
.cursorignore file excludes files and directories from Cursor's indexing.
This is essential for:
- Performance - Avoid indexing node_modules, dist, build, and other heavy directories
- Relevance - Exclude generated files, lock files, and binary assets that add noise
- Security - Prevent sensitive files (API keys, credentials) from being sent to servers
# Dependencies
node_modules/
vendor/
# Build output
dist/
build/
.next/
.angular/
# Generated files
*.min.js
*.min.css
*.map
# Lock files
package-lock.json
yarn.lock
# Binary assets
*.png
*.jpg
*.gif
*.mp4
# Sensitive files
.env
.env.local
*.pem
*.key
Cursor 2.0: Up to 8 Parallel Agents
On October 29, 2025, Anysphere released Cursor 2.0, the most significant update since the editor's inception. The headline innovation is the ability to run up to 8 AI agents in parallel, each working independently on different tasks without interfering with one another.
How Parallel Agents Work
The technology enabling parallel agents is built on git worktrees. A worktree is a Git feature that allows multiple copies of the same repository in different directories, each on a separate branch. Cursor leverages this mechanism to isolate each agent in its own worktree, ensuring that one agent's changes do not create conflicts with another's.
The workflow is as follows:
- Launch - Open the Composer and start up to 8 agents with different tasks
- Isolation - Each agent operates in its own git worktree on a dedicated branch
- Parallel execution - Agents work simultaneously, each modifying its own files without conflicts
- Review - You can monitor the progress of each agent in real time
- Merge - Once completed, results can be merged into the main branch
Background Agents
Beyond the parallel agents visible in the interface, Cursor 2.0 introduced Background Agents: agents that execute tasks in the background, even when you are not actively watching the editor. You can assign a task to a background agent, continue working on something else, and receive a notification when the task is done.
Typical use cases for Background Agents:
- Test generation - "Generate unit tests for all services in the /services folder"
- Migration - "Migrate all components from the old syntax to the new one"
- Code review - "Analyze the codebase and report potential security issues"
- Documentation - "Add JSDoc to all exported public functions"
Cursor 2.0: Key New Features
- Up to 8 parallel agents with isolation via git worktrees
- Composer 1 - First proprietary MoE model, 4x faster
- Background Agents for asynchronous, autonomous tasks
- Agent-first interface with option to switch back to classic file view
- Visual Editor for drag-and-drop UI changes with agent integration
- Browser integration for visual testing and frontend debugging
- Voice control for hands-free AI interaction
- Automatic context gathering for richer context without manual effort
Pricing and Plans: Which One to Choose
Cursor offers several plans to meet the needs of individual developers and teams. Starting in June 2025, the pricing model shifted from fixed requests to a credit-based system, where each AI model consumes a different number of credits based on complexity and computational cost.
Cursor Plans Comparison
| Feature | Free (Hobby) | Pro ($20/month) | Business ($40/user/month) |
|---|---|---|---|
| Tab completions | 2,000/month | Unlimited | Unlimited |
| Premium requests | 50 slow/month | Monthly credit pool | Monthly credit pool |
| Available models | Basic | All (GPT-4o, Claude, etc.) | All + enterprise models |
| Agent Mode | Limited | Full | Full |
| Background Agents | No | Yes | Yes |
| Privacy Mode | Yes | Yes | Yes + admin controls |
| Admin dashboard | No | No | Yes |
| SSO/SAML | No | No | Yes |
| Centralized billing | No | No | Yes |
There is also a Pro+ / Ultra plan at $200/month that provides roughly 20 times more model usage and priority access to new features. It is designed for power users who rely on AI for the majority of their workday.
My Recommendation
Start with the Free plan to test Cursor and assess whether it fits your workflow. The 2,000 completions and 50 premium requests are enough for about a week of moderate use. If you find it valuable, the Pro plan at $20/month offers the best value: unlimited completions and a generous credit pool for premium models. The Business plan only makes sense for teams that need centralized management and enterprise compliance.
Practical Tips: Optimal Workflow
After months of daily Cursor usage, here are the best practices I have found most effective for maximizing productivity:
1. Use the Right Tool for the Right Task
- Fluid writing - Tab autocomplete. Let Cursor complete your code as you type
- Surgical editing - Cmd+K. Select, describe, apply
- Exploration and understanding - Chat (Cmd+L). Ask questions about the codebase
- Multi-file generation - Composer (Cmd+I). Create or modify multiple files together
- Complex autonomous tasks - Agent Mode. Let the AI handle the complete cycle
2. Write Effective Prompts
AI output quality depends directly on prompt quality. Follow these guidelines:
- Be specific - "Add email validation with regex to the input field" is better than "Validate the form"
- Provide context - Use @files to include reference files, @docs for documentation
- Indicate conventions - "Use the same error handling pattern we use in auth.service.ts"
- Define constraints - "Do not modify existing test files, create a new test file"
3. Configure Cursor Rules
Cursor Rules are persistent instructions that guide the AI's behavior for your specific project. They are the key to moving from generic results to output that respects your team's conventions. We will dive deep into this topic in the next article in this series.
# Project Rules
## Stack
- Angular 21 with SSR
- TypeScript strict mode
- SCSS for styling
## Conventions
- Use standalone components (no NgModule)
- Signals for state management
- OnPush change detection
- File names in kebab-case
- Comments and variables in English
## Code Style
- Pure functions when possible
- Immutability: never mutate objects, always create copies
- Explicit error handling in every service
- Max 50 lines per function
4. Always Review the Output
AI is an immensely powerful assistant, but it is not infallible. Adopt a trust but verify workflow:
- Read every generated diff before applying it
- Run tests after every significant change
- Verify that changes respect the project's best practices
- Check that no inconsistent patterns have been introduced
- Use version control so you can roll back problematic changes
5. Leverage Indexing
Codebase indexing is Cursor's superpower. Make sure it is configured properly:
- Verify indexing is complete under Cursor Settings > Features > Codebase Indexing
- Configure
.cursorignoreto exclude irrelevant files - Add relevant external documentation with @docs (frameworks, libraries, APIs)
- Use @codebase when you need the AI to understand cross-project patterns
Conclusions
Cursor represents a fundamental shift in how we write software. It is not simply an editor with AI tacked on: it is a development environment that thinks alongside you, understands your project at a semantic level, and can act autonomously to complete complex tasks.
The question is no longer "Should I use an AI IDE?" but rather "Which AI IDE best fits my workflow?". And for the majority of developers working with modern codebases, Cursor offers the strongest balance of power, flexibility, and ease of use.
Who Is Cursor For
- Individual developers who want to accelerate daily productivity without changing their habits (thanks to the VS Code foundation)
- Development teams looking for a shared tool with customizable AI conventions through Cursor Rules
- Startups and companies aiming to reduce time-to-market by leveraging multi-file generation and parallel agents
- Senior developers who want to delegate repetitive tasks to the AI and focus on architecture and design decisions
When to Stay on VS Code
- If your workflow depends on specific extensions incompatible with Cursor (e.g., Live Share)
- If you work in environments with network restrictions that prevent communication with AI servers
- If you need the full Microsoft marketplace without limitations
- If you prefer a specific tool like GitHub Copilot and do not need Cursor's advanced features
Next Articles in This Series
This is just the first step. In upcoming articles, we will dive deep into every advanced aspect of Cursor to turn you into a power user:
- Article 2 - Cursor Rules: How to create custom rules that guide the AI to generate code perfectly suited to your project
- Article 3 - Agent Mode Deep Dive: Advanced strategies for delegating complex tasks to the AI agent
- Article 4 - Plan Mode: How to use AI-assisted planning for complex features
- Article 5 - Hooks and MCP: Extending Cursor with external tools and custom integrations
- Article 6 - Professional Workflows: Patterns and best practices for development teams