Chat & Inline Editing

The AI side pane excels at tasks that require back-and-forth discussion, exploration, or multi-step reasoning.

Best use cases for Chat:

• Explaining complex code or architecture
• Planning a feature before writing code
• Debugging — describing a problem and iterating on solutions
• Asking "how should I approach X?" questions
• Generating boilerplate that you'll refine through conversation

Multi-turn workflow example:

You: How is authentication handled in this project?

AI: [Explains the auth flow based on your codebase]

You: I want to add rate limiting to the login endpoint. What's the best approach?

AI: [Suggests approaches, considering your existing stack]

You: Let's go with approach 2. Can you write the middleware?

AI: [Generates the code with an Apply button]

Notice how each message builds on the previous context. The AI remembers everything discussed in the current session.

Applying code from Chat:

When the AI generates code in the AI side pane, you'll see an Apply button above code blocks. Click it to:

• Insert the code at your cursor position, or
• Replace selected code in the editor, or
• Create a new file with the generated content

Inline editing (Cmd+K / Ctrl+K) is for quick, surgical changes where you know exactly what you want and where you want it.

Effective inline edit prompts:

Generating new code (no selection):

If you press Cmd+K / Ctrl+K without selecting anything, the AI generates new code at the cursor position. This is useful for:

• "Write a function that validates email addresses"
• "Add an import for React useState"
• "Create a test case for the above function"

The generated code appears as a diff — green lines showing what will be inserted.

Iterating on inline edits:

If the first result isn't quite right but is close:

1. Accept the edit (Tab)
2. Select the result
3. Press Cmd+K / Ctrl+K again
4. Refine: "Almost — but use a Map instead of an object"

This iterative approach is often faster than crafting one perfect prompt.

The code you select before triggering AI is crucial — it determines what the AI understands about your intent.

Selection strategies:

How to select effectively:

Context in Chat vs Inline:

• Cmd+K (Inline): Only the selected code and the current file are visible to the AI
• Cmd+L (Chat): The selected code is attached, but the AI can also reference other files in the project

This is why Chat is better for cross-file tasks and Inline is better for focused, single-location edits.

Every AI suggestion in Cursor requires your explicit approval. Here's how to handle each response:

For Inline Edits (Cmd+K):

For Chat suggestions:

The diff view in detail:

When an inline edit generates a diff:

• Red background = lines being removed
• Green background = lines being added
• No background = unchanged context lines
• The left gutter shows − and + markers

You can scroll through multi-section diffs using the up/down arrows in the diff toolbar.

Undoing accepted changes:

If you accept a change and then realize it was wrong:

Choosing the right tool for the task saves time and produces better results:

Use Chat (Cmd+L / Ctrl+L) when:

• You need to explain or understand code
• The task requires planning before coding
• You want to discuss trade-offs between approaches
• The change involves multiple files or complex logic
• You're debugging and need to iterate on the problem description
• You want to generate a new file from scratch

Use Inline Edit (Cmd+K / Ctrl+K) when:

• You know exactly what change you want
• The change is localized to one spot in one file
• You want a quick transformation (add types, rename, convert syntax)
• You're iterating rapidly — make a change, test, adjust
• The instruction fits in a short sentence

Decision flowchart:

1. Can you describe the change in one short sentence? → Inline Edit
2. Do you need to ask questions first? → Chat
3. Is it a single-file change? → Inline Edit
4. Does it span multiple files? → Chat (or Agent)
5. Are you exploring/learning? → Chat
6. Are you executing a known change? → Inline Edit

Combining both — the power workflow:

1. Open Chat, ask: "How should I add validation to the user signup form?"
2. Review the AI's suggested approach
3. Navigate to the file mentioned
4. Select the relevant function
5. Press Cmd+K: "Add validation for email, password length > 8, and required fields"
6. Accept the inline change
7. Back in Chat: "Now I need the matching error messages in the response"

This workflow uses Chat for thinking and Inline for doing.

Chat becomes dramatically more useful when you give it context about multiple files. Use the @ symbol in the chat input to reference files, symbols, and more.

Basic @file references:

In the Chat input, type @ followed by a filename:

@src/auth/login.js I want to add rate limiting to this endpoint.
How should I implement it given the existing middleware pattern?

The AI will read the referenced file and use it as context for its response.

Multiple file references:

@src/models/user.js @src/routes/auth.js @src/middleware/validate.js
These three files handle user authentication. I want to add
two-factor authentication. What changes are needed in each file?

How to use @file effectively:

1. Type @ in the chat input
2. Start typing the filename — Cursor shows autocomplete suggestions
3. Select the file from the dropdown
4. The file appears as a pill/chip in the context bar above the input
5. Type your question or instruction

What you can reference with @:

Removing context:

Click the X on any context chip to remove it from the conversation. This helps if you've attached too many files and the AI is getting confused.