Cursor is VS Code rebuilt around AI. Same extensions, same keybindings, same familiarity—but with AI woven into every interaction.
If you’re still using GitHub Copilot in VS Code, Cursor offers a more integrated experience. Here’s how to use it effectively.
What Makes Cursor Different
Deep Integration
Copilot feels bolted on. Cursor feels native. The AI understands:
- Your entire codebase (not just the current file)
- Project structure and dependencies
- Recent changes you’ve made
- Terminal output and errors
This context awareness produces better suggestions.
Multiple Interaction Modes
- Tab completion - Inline suggestions as you type
- Cmd+K - Edit selected code with natural language
- Cmd+L - Chat about your code with full context
- Composer - Multi-file changes from a single prompt
Different tasks need different modes. Cursor provides all of them.
Codebase Indexing
Cursor indexes your entire project, creating embeddings that let the AI find relevant code anywhere in your codebase. Ask “where do we handle authentication?” and it finds the answer across thousands of files.
Getting Started
Installation
Download from cursor.com. It imports your VS Code settings, extensions, and keybindings automatically. The transition takes minutes.
First Run
Open a project. Cursor indexes it in the background. Larger codebases take longer, but you can start working immediately.
Model Selection
Cursor offers multiple models:
- GPT-4 - Strong reasoning, slower
- Claude - Excellent for complex code
- cursor-small - Fast, good for simple completions
Switch based on the task. Use fast models for autocomplete, powerful models for complex refactoring.
Core Features
Tab Autocomplete
Start typing. Cursor suggests completions. Press Tab to accept.
What makes it better than standard autocomplete:
- Multi-line suggestions
- Understands your patterns
- Considers imported modules
- Follows your coding style
Cmd+K: Inline Editing
Select code. Press Cmd+K. Describe the change.
Selected: function fetchUser(id) { ... }
Prompt: "add error handling and retry logic"Cursor rewrites the selection. Review the diff and accept or reject.
Use cases:
- Add error handling
- Convert to async/await
- Add TypeScript types
- Refactor for readability
- Add logging
- Optimize performance
Cmd+L: Chat
Open the chat panel to discuss code with context. The AI sees:
- Your current file
- Selected code (if any)
- Files you reference with @
- Your terminal output
Ask questions:
- “Why is this function slow?”
- “How should I structure this feature?”
- “What’s the best way to test this?”
Get explanations, suggestions, and code snippets in response.
@ Mentions
Reference specific context in chat:
@filename.ts- Include a specific file@folder- Include a directory@codebase- Search entire project@docs- Reference documentation@web- Search the internet
Example: “Using @api/auth.ts as reference, create a similar endpoint for @api/users.ts”
Composer
For changes spanning multiple files:
- Press Cmd+I to open Composer
- Describe what you want to build
- Cursor plans the changes across files
- Review each file’s modifications
- Accept all or selectively
Composer excels at:
- Adding new features
- Refactoring across modules
- Creating new components with tests
- Implementing patterns consistently
Effective Workflows
Writing New Code
- Create the file
- Write a comment describing what you want
- Let Cursor generate the implementation
- Tab through suggestions, editing as needed
- Use Cmd+K to refine specific sections
Debugging
- Select the problematic code
- Cmd+L to open chat
- Paste the error message
- Ask “why is this failing?”
- Apply the suggested fix with Cmd+K
Refactoring
- Select the code to refactor
- Cmd+K with clear instructions:
- “Extract this into a custom hook”
- “Convert to TypeScript with strict types”
- “Split into smaller functions”
- Review the diff carefully
- Accept or iterate
Learning New Codebases
- Open the project in Cursor
- Let it index
- Use chat with @codebase:
- “How does authentication work?”
- “Where are API routes defined?”
- “What’s the data flow for user creation?”
The AI explains with references to actual files.
Code Review
- Open the diff
- Select changed code
- Ask: “Review this change for potential issues”
- Get feedback on bugs, edge cases, and improvements
Tips for Better Results
Be Specific
Vague: “Make this better” Specific: “Add null checks, handle the loading state, and memoize the expensive calculation”
Provide Context
“Using our existing Button component style, create a SubmitButton that shows a loading spinner”
Reference Examples
“Following the pattern in @UserService.ts, create an OrderService with the same error handling”
Iterate
Don’t accept the first suggestion blindly. If it’s close but not right:
- Cmd+K again with refinements
- “Make it also handle the edge case where…”
- “Actually, use X approach instead”
Review Carefully
AI makes mistakes. Always:
- Read the generated code
- Check edge cases
- Verify types are correct
- Run tests after accepting changes
Keyboard Shortcuts
Essential shortcuts to memorize:
| Action | Shortcut |
|---|---|
| Accept suggestion | Tab |
| Reject suggestion | Esc |
| Inline edit | Cmd+K |
| Open chat | Cmd+L |
| Composer | Cmd+I |
| Toggle AI panel | Cmd+Shift+L |
Cursor vs Alternatives
vs GitHub Copilot
Cursor advantages:
- Better codebase awareness
- Multiple interaction modes
- Faster iteration on changes
- More model options
Copilot advantages:
- Works in existing VS Code
- GitHub integration
- Familiar if already using
vs Claude Code (CLI)
Different tools for different contexts:
- Cursor: GUI-based, integrated editing
- Claude Code: Terminal-based, autonomous tasks
Many developers use both.
vs ChatGPT/Claude Web
Cursor advantages:
- Code context is automatic
- Changes apply directly to files
- No copy-paste workflow
- Version control integration
Web chat advantages:
- Better for learning/explanation
- No setup required
- Conversation history
Limitations
Hallucinations - AI sometimes generates plausible but wrong code. Always verify.
Context limits - Very large codebases may exceed context windows. Use @ mentions strategically.
Cost - Pro features require subscription. Free tier has limits.
Learning curve - Knowing when to use which feature takes practice.
Pricing
- Free - Limited AI requests per month
- Pro - Unlimited standard requests, more powerful models
- Business - Team features, admin controls
For serious development, Pro pays for itself in productivity gains.
Getting the Most Value
- Use it for everything - The more you use it, the more natural it becomes
- Learn the shortcuts - Keyboard efficiency matters
- Index important projects - Let Cursor understand your codebases
- Combine modes - Tab for quick completions, Cmd+K for edits, Cmd+L for understanding
- Stay critical - AI assists, you decide
Cursor doesn’t replace programming skill. It amplifies it. The developers who benefit most are those who know what good code looks like and can evaluate AI suggestions critically.
Try it for a week. You probably won’t go back.