Lesson 26: IDE Integrations

Day 26 of 50 · ~7 min read · Phase 4: Integrations

The Opening Question

So far, you've been using Claude Code in your terminal. You type claude, have a conversation, and Claude modifies your files.

But you spend most of your time in an IDE — VS Code, JetBrains IntelliJ, or whatever you use. Your editor is where you write code, read files, run tests, debug.

Here's the question: Should Claude Code live in your terminal, or should it live in your editor?

And more broadly: When does each interface make sense?

Discovery

Let's think through the tradeoffs.

Question 1: Why would Claude Code live in your IDE instead of your terminal?

Let's imagine two workflows:

Terminal workflow: You type claude "add error handling to auth.js". Claude works. You see the agentic loop in your terminal. Once Claude is done, you switch to your editor to review the changes.

IDE workflow: You're already in VS Code. You highlight a function. You hit a keyboard shortcut. Claude adds error handling right there in your editor. You see inline diffs. You approve or reject with a click.

What's the difference?

Pause and think: Where do you spend more time — in your terminal or in your editor?

The IDE workflow has advantages:

1. Proximity. Claude is where you're already working. No context switching.
2. Inline editing. You see diffs inline, right in the file. Easier to review.
3. File context. The editor shows you the file you're working on automatically. Claude doesn't have to ask.
4. Keyboard shortcuts. Faster than typing commands.
5. Multi-file collaboration. Some IDEs let you have Claude work across multiple files in a tab group.

But it also has tradeoffs. The IDE can't show you the agentic loop as clearly as the terminal can. You lose some visibility into what Claude is doing.

Question 2: What IDE integrations are available?

Claude Code has integrations with major IDEs:

VS Code — There's an official Claude Code extension for VS Code. It gives you:

• Inline diff view (see changes right in the editor)
• / shortcuts for slash commands
• @ mentions to include specific files
• Inline chat (ask Claude questions about code you're looking at)
• Multi-tab editing (Claude can work across multiple files at once)

JetBrains IDEs — IntelliJ, PyCharm, WebStorm, etc. The JetBrains plugin does similar things:

• Inline diffs
• Command shortcuts
• Chat in the editor
• Right-click context menu ("Ask Claude Code to...")

Desktop App — There's also a standalone Claude Code desktop app. It's not in your IDE, but it's a native app, not a terminal. It gives you a GUI without leaving your computer.

Others — Sublime, Vim, Neovim, Emacs plugins exist or are in development.

Each of these has different strengths and tradeoffs.

Pause and think: Which one sounds most natural for how you work? Are you a terminal person or an editor person?

Question 3: When does each context make sense?

Let's be practical. You don't have to pick one. You can use Claude Code in the terminal and in your IDE, depending on what you're doing.

Use the terminal when:

• You're doing something exploratory or complex
• You want to see the agentic loop clearly
• You want full, multi-turn conversations with Claude
• You're doing operations that span the whole project (refactoring, searching, understanding structure)
• You want to use slash commands and custom workflows

Use the IDE when:

• You're focused on a single file or small change
• You want to make a quick edit and immediately see the diff
• You're doing code review — you want to accept/reject changes quickly
• You want to leverage your editor's navigation (go to definition, find usages, etc.)
• You want to stay in flow without switching windows

Use the desktop app when:

• You want a GUI experience without the terminal
• You're moving between different projects frequently
• You want a dedicated window just for Claude Code

Here's a concrete example of when you'd use each:

Terminal: "I don't understand how this API authentication works. Read the auth module, find the issue with expired tokens, and fix it."

IDE: You're in auth.js, you select a function, you think "this needs error handling," you hit a shortcut, Claude adds it right there.

Desktop: You're context-switching between projects a lot. You want Claude in its own window so you can see both Claude and your editor side-by-side.

Question 4: How do you choose what to use?

Here's the honest answer: most developers end up using both.

The terminal is best for:

• Complex, multi-step tasks
• Understanding a new codebase
• Refactoring or major changes
• When you want to see what Claude is thinking

The IDE is best for:

• Quick edits
• Code review
• Staying in flow
• Single-file changes

You don't have to decide once and for all. You can use the terminal for deep work and the IDE for quick fixes. Or vice versa.

The key question to ask yourself: Where am I right now, and what makes sense?

Pause and think: Think about the last 5 coding tasks you did. For each one, would the terminal or the IDE have been faster?

The Insight

Here's what's really happening with IDE integrations:

Claude Code isn't locked into the terminal. It's available wherever you work — in your IDE, in a desktop app, in the terminal. Each context has different strengths. The terminal is best for exploration and complex reasoning. IDEs are best for quick, focused edits. Choosing the right context for the task makes you faster and keeps you in flow.

The mental model: Claude Code is like a colleague who can work wherever you are. When you're at your desk deep in the code (IDE), they're right there with you. When you're at a whiteboard thinking through architecture (terminal/conversation), they're there too. The best developers use both, switching based on what makes sense.

Try It

Let's set up an IDE integration.

1. Pick your IDE. (Or use whichever you use most.)

2. If using VS Code:

   • Open the Extensions marketplace (Cmd+Shift+X on Mac, Ctrl+Shift+X on Windows/Linux)
   • Search for "Claude Code"
   • Click Install
   • Once installed, you'll see a Claude icon in the sidebar
   • Click it to open the Claude Code panel

3. If using JetBrains (IntelliJ, PyCharm, etc.):

   • Go to Settings → Plugins
   • Search for "Claude"
   • Click Install on the Claude Code plugin
   • Restart your IDE
   • You'll see Claude Code in the right sidebar

4. Test it. Open a file and try:

   • Select some code
   • Right-click and choose "Ask Claude Code" (or similar)
   • Ask Claude to improve the code
   • Watch the inline diff appear

5. Now compare to the terminal. For the same task:

   claude "Improve this code in [filename]"
   

   Notice the difference in how you interact with Claude.

6. Mix and match. Do a few tasks in the IDE, then switch to the terminal for a more complex task. Notice which context feels more natural for each.

Key Concepts Introduced

Bridge to Lesson 27

You've now learned about IDE integrations — bringing Claude Code into the tools you use daily.

But here's something that's been lurking in the background: how does Claude Code stay safe? What prevents it from doing something dangerous?

Tomorrow's question: What keeps Claude Code from breaking things?

We'll explore hooks — automated checks that run before Claude's changes are committed, preventing mistakes before they become problems.

← Back to Curriculum · Lesson 27 →