SECTION 01
The Three Operations to Learn First in Cursor
Cursor has a lot of features, but you only need to learn three operations to get started. By using Tab completion, inline editing (Cmd+K), and chat effectively, your daily development workflow will change dramatically.
Tab completion predicts and suggests your next input as you write code. Unlike standard autocomplete, it reads your recent changes, surrounding code, and the overall project context before making suggestions.
Inline editing (Cmd+K) lets you select code, press the shortcut, and give instructions like "convert to async/await" or "add error handling." Changes appear as a diff, and you can choose to Accept or Reject each one.
Chat (invoked with Cmd+L, etc.) lets you ask questions about code or generate code through a sidebar conversation. Cmd+L can also send selected code to a new chat. From experience, the easiest adoption path is: "Start with Tab completion → then try inline editing → use chat for larger changes." Trying to use everything at once leads to confusion, so building up gradually is the reliable approach.
SECTION 02
When to Use Chat, Inline Editing, and Agent Mode
Beyond the three core operations, there's Agent mode—a feature that handles changes spanning multiple files at once. The simplest way to decide which feature to use is by the "scope" of the change.
Here's a quick guide:
- Partial edits in a single file → Inline editing (Cmd+K)
- Changes across multiple files → Agent mode
- Research, design discussions, debugging → Chat
Agent mode is powerful, but the larger the change, the higher the risk of unintended modifications creeping in. As the number of files grows, it becomes harder to review all the diffs. Use it with the expectation that you'll review everything—not as a "generate and forget" tool.
Agent mode tends to break down when you try to change areas where existing logic is tightly interconnected all at once. In these cases, progressing one file at a time with inline editing is often faster in the end.
Another critical concept is context specification. In chat and Agent mode, you can use "@filename" to reference specific files, "@Codebase" to search the entire project, and "@Docs" to include external documentation as reference material.
Without narrowing the context, the AI may reference irrelevant files and make off-target suggestions. Deciding "what to show" before giving instructions is the most effective habit for improving output accuracy.
SECTION 03
First Settings to Configure When Migrating from VSCode
Cursor is built on VSCode, so you can import your VSCode settings, extensions, and keybindings. Just go to the Settings screen, find "VS Code Import," and click the Import button. The migration itself is smooth, but there are a few points that need manual adjustment.
For Japanese localization, simply install the Japanese Language Pack, just like in VSCode. Search for "Japanese" in the extensions panel, install it, restart, and the menus will be in Japanese.
One thing to watch out for is the difference in extension marketplaces. VSCode pulls extensions from Microsoft's Visual Studio Marketplace, but Cursor uses the Open VSX Registry as its base. Most extensions are published on both, but some Microsoft-made extensions may not be available on Open VSX or may have compatibility issues.
For example, C# Dev Kit isn't available on Open VSX due to licensing restrictions. For Python language support, Cursor sometimes provides its own compatible extensions, so it's worth trying before concluding something "doesn't work."
For extensions not found on Open VSX, you can also manually install VSIX files. That said, Cursor's AI features can sometimes compensate for missing extensions, so it's best to stay flexible and consider alternatives.
You'll also want to check Cursor-specific settings. In the Settings screen, you can configure AI model selection (Auto, Claude, GPT, etc.), Privacy Mode on/off, and Tab completion behavior.
In particular, turn on Privacy Mode first if you're using Cursor for work. When Privacy Mode is enabled, your code won't be used for model training by Cursor or third parties. This is an important setting to verify when working with business code.
SECTION 04
Stabilizing Output Quality with Cursor Rules
As you keep using Cursor, you'll notice the inefficiency of repeating the same instructions every time. Telling it "Write in TypeScript," "Comments in Japanese," or "Follow this naming convention" in every prompt is tedious. Cursor Rules solve this problem.
Rules are placed in the .cursor/rules directory at the project root. They use the .mdc format, where you can specify conditions based on file patterns. For example, you can apply React conventions only to frontend code while using different rules for the backend.
The most effective things to include in Rules are:
- Coding conventions (naming rules, indentation, comment language)
- Tech stack (frameworks, versions, library setup)
- Forbidden patterns (banning
any, restricting certain functions, etc.)
On the other hand, writing too many rules can confuse the AI. When contradictory rules exist, the AI can't determine which to prioritize and produces half-baked output. Through trial and error, a good guideline is to keep each file to around 20 lines maximum.
Note that Rules apply to Agent (chat) output only—they don't apply to inline editing (Cmd+K). User Rules also only take effect on the Agent side. When setting up Rules, understanding that they're primarily for stabilizing output quality in Agent mode and chat will help align your expectations.
Rules come in two types: project-level and global settings. Project Rules are shared with your team and version-controlled; global Rules are personal settings configured from the Settings screen. For team development, include .cursor/rules in the repository and make rules a review target alongside code.
Previously, there was a method of placing a file called .cursorrules at the project root, but this is now deprecated. If you're still using it, migrate to the .cursor/rules directory sooner rather than later.
SECTION 05
Integrating External Tools with MCP
MCP (Model Context Protocol) is a communication standard that connects AI editors with external tools. With Cursor's MCP support, you can now pass external information—like database references, API specs, and documentation—directly into the AI's context.
There are two ways to configure MCP:
- Settings screen → Tools & MCP → Add new MCP server
- Configuration file (~/.cursor/mcp.json) with direct entries
The main connection methods are stdio (local execution, the most common) and Streamable HTTP (supports remote execution). For individual development, stdio is sufficient. After writing the configuration file, you need to fully restart Cursor. Forgetting this and wondering "why won't it connect" is a common pitfall.
MCP shines when you have external information you access repeatedly. For example, it eliminates the need to explain database schemas every time, or lets you pass GitHub Issue and Slack context directly. Conversely, for tasks that only involve simple code completion or refactoring, there's no need to set up MCP.
The most reliable way to verify it's working is to add the MCP server, then try calling it from chat with something like "Use this tool to get the list of DB tables." If it doesn't work, run the mcp.json command directly in the terminal to check for errors. Since Cursor sometimes swallows errors internally, manual verification in the terminal is the most reliable debugging method.
SECTION 06
Free Plan Limitations and When to Upgrade
Cursor's free plan (Hobby) is sufficient for trying out Tab completion and chat features. However, with continued use, you'll inevitably hit the request limit.
The first limitations you'll feel on the free plan are:
- Tab completion has a request limit
- Access to high-performance models (latest Claude, GPT, etc.) is restricted
- Agent mode usage is also limited
The paid plans are currently structured as Hobby (free) / Pro / Pro+ / Ultra / Teams / Enterprise.
The Pro plan significantly expands Agent request limits and unlocks access to frontier models along with advanced features like MCP and cloud agents. Pro+ and Ultra further expand Pro's usage quotas.
Teams adds team management features including shared rules, consolidated billing, and usage reports. Enterprise adds additional features for larger organizations.
Note that Cursor's pricing model applies usage-based pricing once included usage is exceeded. Each plan includes a usage quota corresponding to its monthly fee, and consumption varies depending on the model and features used. Since specific limits and prices change frequently, checking the official pricing page for the latest information is the safest bet.
To summarize the decision criteria: the free plan is often enough for hobby-scale projects. If you use it daily for work, upgrading to Pro is well worth it. If your team needs administrators to track everyone's usage, Teams becomes a viable option.
SECTION 07
Practical Cursor Tips That Make a Real Difference
Beyond the basics, there are practical techniques that further accelerate development speed. Here are the ones that have proven effective in daily use.
First, leverage the codebase index. When you open a project, Cursor indexes all code in the background. Once this completes, the accuracy of responses when using "@Codebase" improves dramatically. Waiting for the initial indexing to finish is the key to a great first experience.
Next, how you write prompts in chat matters. Instead of vague instructions like "fix this code," writing something like "Change the error handling in this function to return an empty array when the value is null" with specific inputs, outputs, and conditions is far more likely to produce the correct result on the first try.
When using Agent mode, committing with git before starting is an essential rule. Since it modifies multiple files, you need to be able to revert quickly if unintended changes slip in.
- Commit before starting to secure a safe state
- Review Agent's changes via diff before committing
- Run tests to verify behavior before moving to the next task
AI model selection also matters more than you'd think. Auto mode offers a good balance of cost efficiency and speed, and is sufficient for everyday use. Switching to a higher-tier model only for complex logic design or large refactors lets you use your usage quota efficiently.
SECTION 08
Summary: How to Use Cursor for Faster Development
Here's everything covered above, organized as a checklist you can act on right away. Review it right after setup and again once you're comfortable with the basics.
Right after setup:
- Enable Tab completion and get used to in-line suggestions
- Try Cmd+K (inline editing) for function-level fixes
- Use Chat for error investigation and design discussions
- Import your VSCode settings and extensions
- Verify your Privacy Mode settings
Once you're comfortable:
- Add project-specific rules to .cursor/rules
- Try Agent mode for multi-file changes
- Connect MCP servers to leverage external information
- Consider upgrading to the Pro plan when the free version feels limiting
The essence of Cursor is incorporating "how to instruct AI" into your daily development workflow. You don't need to memorize every feature—the fastest path is to start with operations that match your work patterns and expand from there.
Starting with just Tab completion is perfectly fine. Building up small wins and gradually expanding your repertoire at your own pace is the key to getting long-term value from Cursor.
