Cursor crossed $1 billion in annualized revenue in 2025, with over a million paying developers. Most of them use less than 20% of what it can do. If you are still evaluating, start with our Cursor AI review. This guide covers the advanced features.
Cursor is no longer just "VS Code with AI." It has evolved into three distinct interaction modes, a configuration system for project-specific AI behavior, and a protocol for connecting AI to external data sources. For a breakdown of plans and costs, see our Cursor AI pricing guide.
For understanding code, asking architecture questions, and planning before implementation. Does not modify files. Use it for Discovery and Design phases.
For generating and applying code changes across multiple files simultaneously. You review diffs before accepting. Ideal for feature implementation with human oversight. Our Cursor Composer guide covers multi-file editing workflows in depth.
For tasks where the AI runs terminal commands, reads output, iterates on errors, and makes changes autonomously. Best for well-defined tasks with clear acceptance criteria. Learn more about autonomous workflows in our Background Agent guide.
The old single .cursorrules file is deprecated. The modern system uses a directory of .mdc files, each with YAML frontmatter that controls when and how rules activate. For more practical rule-writing advice, see our Cursor tips and tricks guide.
Example: .cursor/rules/react-components.mdc
Set alwaysApply: true for rules that should apply in every conversation. Use for your tech stack definition, coding standards, and global patterns. Keep these concise -- under 300 lines.
Use globs patterns to activate rules when matching files are in context. A migration rule triggers only when working with database files. This keeps context lean and relevant.
Rules you invoke explicitly with @rulename. Useful for specialized workflows like "deploy checklist" or "security audit" that you only need occasionally.
Model Context Protocol (MCP) connects Cursor to external data sources. Instead of copy-pasting your database schema or API docs into the chat, MCP lets the AI query them directly.
Example: .cursor/mcp.json
Connect to PostgreSQL, MySQL, or SQLite so the AI can see your actual table schemas, column types, and relationships. Eliminates hallucinated column names and wrong foreign key references.
Feed your internal docs, API specifications, or framework documentation directly to Cursor. The AI searches these docs instead of relying on potentially outdated training data.
Connect to Linear, Jira, or GitHub Issues so the AI can read ticket descriptions and acceptance criteria directly, ensuring the implementation matches requirements.
Link to Sentry or Bugsnag to give the AI real error traces and stack dumps when debugging, rather than describing the error in natural language.
| Capability | Cursor | GitHub Copilot | Windsurf | Claude Code |
|---|---|---|---|---|
| Codebase Indexing | Full semantic RAG | @workspace search | Full indexing | File-based context |
| Persistent Rules | .cursor/rules/ with glob activation | .github/copilot-instructions.md | .windsurfrules | CLAUDE.md |
| Multi-File Editing | Composer + Agent mode | Copilot Edits | Cascade flows | Direct file edits |
| MCP Support | Project + global config | Limited | Supported | Native MCP support |
| Background Agents | Cloud sandbox agents | Copilot Workspace (preview) | Not available | Headless mode |
| Pricing | $20/mo (credit-based) | $10-19/mo | $15/mo | $20/mo (via Max plan) |
The biggest mistake developers make is over-tagging files. When you @-mention a file, its entire content is added to the AI's context window. Tagging 20 files means the AI is processing thousands of lines of code -- most of which are irrelevant to the current task and actively dilute its attention.
Instead, tag only the 2-4 files directly relevant to the task. If implementing a new API endpoint, tag the route file, an existing similar controller (as a pattern reference), and the relevant model. Skip utility files, configs, and unrelated components.
Use @codebase when you need the AI to find something you are not sure where it lives -- "where is the authentication middleware defined?" Use @file when you know exactly which files matter and want focused attention on them.
The codebase index is a semantic search, not a full scan. It returns the most relevant chunks, which means it can miss things in very large repositories. For critical context, always use direct @file references.
After the AI generates code in a Composer or Agent session, do not review it in the same conversation. Start a fresh Chat session, @-tag the generated files, and ask the AI to review them as if it is seeing them for the first time. This "adversarial review" pattern eliminates the confirmation bias that occurs when the same context is used for both generation and review.
In late 2025, Cursor migrated from a single .cursorrules file to a directory-based system at .cursor/rules/. You now create individual .mdc files with YAML frontmatter that specify activation modes: "always" (loaded in every conversation), "auto" (loaded when matching file patterns are open), or "manual" (only when explicitly referenced). This lets you create modular, composable rules -- for example, one rule for your React component conventions, another for your API patterns, and another for database migrations. The old single-file approach still works but is deprecated.
Model Context Protocol (MCP) servers give Cursor's AI access to external data sources -- your database schema, API documentation, project management tickets, or deployment logs -- without manually copy-pasting context. You configure them in .cursor/mcp.json at the project level or in global settings. In 2026, MCP has become essential for production workflows: you can connect Cursor to your PostgreSQL database so it can see actual table schemas, to your Sentry instance for error context, or to your Jira/Linear board so it understands the ticket it is implementing. This eliminates the most common source of hallucinations: the AI guessing about data structures it cannot see.
Chat is for asking questions and getting explanations without modifying files. Composer is for multi-file code generation where you review and apply changes. Agent mode (introduced in 2025 and expanded in 2026) gives Cursor autonomous capabilities: it can run terminal commands, read files, execute tests, and iterate on errors without manual intervention. For senior developers, the typical workflow is: use Chat for the Discovery and Design phases, then switch to Agent mode for implementation, and return to Chat in a fresh context for review.
Context management is the single most important Cursor skill. Use @-mentions strategically: @file for specific files, @folder for directory context, @codebase for semantic search across your project. Avoid tagging everything -- more context is not better context. A focused set of 3-5 relevant files outperforms dumping 20 files into the conversation. For large projects (50K+ lines), create .cursor/rules/ files that pre-load architectural context so you do not need to re-explain your patterns in every conversation.
As of early 2026, Cursor Pro costs $20/month with a credit-based system where usage varies by model (Claude Sonnet is cheaper per request than Opus, for example). GitHub Copilot costs $10-19/month. The key difference is workflow depth: Copilot excels at inline completions and single-file edits, while Cursor's Composer and Agent modes handle multi-file refactors, architectural changes, and iterative debugging loops that Copilot cannot match. For developers working on complex production codebases, Cursor's agentic capabilities justify the premium. For simple autocomplete needs, Copilot or free tools like Cody may suffice.
Start with an "always-on" rule file that defines your tech stack, coding conventions, and architectural patterns. Keep it under 500 lines -- concise rules outperform verbose ones. Then create auto-activated rules for specific file types: a React component rule that triggers when .tsx files are open, a migration rule for database files, a test rule for your test directory. Each rule should include concrete examples of correct code, not just abstract guidelines. For instance, instead of "follow our naming conventions," show the AI an actual model with the correct naming pattern. Update rules as your codebase evolves.
Background Agents, introduced in early 2026, let Cursor work on tasks asynchronously in cloud sandboxes while you continue coding. You can assign a task like "refactor all API routes to use form request validation" and Cursor will create a branch, make the changes, run tests, and open a pull request -- all in the background. This is ideal for well-defined, low-ambiguity tasks like adding type hints, writing test coverage for existing code, or migrating deprecated API patterns. Avoid using them for tasks requiring architectural judgment or business logic decisions where you need to steer the implementation.
Three techniques work together: First, use .cursor/rules/ to explicitly state your patterns with code examples. Second, use @-mentions to include reference files that demonstrate the correct patterns -- when implementing a new controller, @-tag an existing controller that follows your conventions. Third, start each conversation with a brief context statement: "Follow the patterns in the referenced files. Do not introduce new libraries or patterns not already present in this codebase." These constraints dramatically reduce pattern drift and hallucinated dependencies.
The Cursor mastery techniques covered here are part of a 12-chapter course that also covers Claude Code, prompt engineering, AI-assisted debugging, and production deployment workflows.
Get Instant Access -- $79.99