Back to Blog
5 - Claude CLI in VS Code: Your AI Pair Programmer, Now in Full HD

5 - Claude CLI in VS Code: Your AI Pair Programmer, Now in Full HD

November 06, 2025
1 views

Table of Contents

Introduction

Remember when you had to choose between your cozy IDE and the power of Claude CLI? Tab-switching like a maniac, copying code back and forth, losing your flow every 30 seconds?

Yeah, those days are over.

With the new Claude Code VS Code extension (beta) and enhanced terminal integration, you get real-time inline diffs, auto-accept mode, multiple parallel sessions, and enough keyboard shortcuts to make you feel like a terminal wizard who moonlights as an IDE master.

This isn't just "Claude in a sidebar." This is Claude becoming your IDE workflow. By the end of this guide, you'll have:

  • ✨ The native VS Code extension running with live diffs
  • ⌨️ Keyboard shortcuts that eliminate mouse usage entirely
  • 🔄 Multiple Claude instances working in parallel (frontend + backend + tests simultaneously)
  • 🎯 VS Code tasks for one-click AI operations
  • ⚡ Permission-skip aliases that stop interrupting your flow

Let's turn VS Code into your AI-powered productivity machine.

The New VS Code Extension (Beta)

In late 2024, Anthropic dropped the native VS Code extension for Claude Code, and it's a game-changer.

What Makes It Special?

Before: Terminal-Only Life

# Terminal → make changes → alt-tab to editor → review → back to terminal
claude "refactor this function"
# 😫 Can't see changes in real-time

After: Native Extension

| Feature | What It Does | Why It Matters | |---------|--------------|----------------| | ⚡ Spark icon sidebar | Dedicated Claude panel in your IDE | No more terminal switching | | 👁️ Real-time inline diffs | See exactly what Claude wants to change, line by line | Review before accepting | | 📋 Plan review mode | Review and edit Claude's plan before it executes | Catch issues early | | 🚀 Auto-accept mode | Trust mode: changes apply automatically | 10x faster for routine tasks | | 🔀 Multiple sessions | Run different conversations in parallel tabs | Frontend + backend + tests | | 🔌 MCP server integration | Model Context Protocol support built-in | Custom tools available | | 📚 Conversation history | Access all previous chats | Never lose context |

Think of it as upgrading from "Claude via carrier pigeon" to "Claude living in your editor."

Requirements

| Requirement | Version | Notes | |-------------|---------|-------| | VS Code | 1.98.0+ | Also supports Cursor, Windsurf, VSCodium | | Claude Code account | Any tier | API key or third-party provider | | Courage | 100% | To trust auto-accept mode (optional but liberating) |

VS Code Integration Architecture How Claude Code integrates with VS Code - extension, terminal, tasks, and keyboard shortcuts working together

What's Still Missing (for now)

The extension is beta, so some features remain CLI-only:

  • Full MCP server configuration
  • Subagent setup
  • Checkpoints (coming soon!)
  • Advanced shortcuts (#, ! commands)
  • Tab completion

For these, you'll use the terminal integration (which is still awesome).

Installation & Setup

Step 1: Install the Extension

Via VS Code Marketplace:

  1. Open VS Code
  2. Click Extensions (Cmd+Shift+X / Ctrl+Shift+X)
  3. Search "Claude Code"
  4. Click "Install" on the official Anthropic extension
  5. Look for the ⚡ Spark icon in your sidebar

Via Command Line:

code --install-extension anthropic.claude-code

Step 2: Authenticate

When you first open the extension:

  1. Click the ⚡ Spark icon
  2. Choose authentication method:
    • Anthropic API Key (default)
    • Amazon Bedrock
    • Google Vertex AI

For Anthropic API:

  • You'll be prompted to log in via browser
  • Authorize VS Code
  • Done!

For Third-Party Providers:

Open VS Code Settings (Cmd+, / Ctrl+,), search for "Claude Code: Environment Variables", and add:

Bedrock:

{
  "claude-code.environmentVariables": {
    "CLAUDE_CODE_USE_BEDROCK": "true",
    "AWS_REGION": "us-east-1",
    "AWS_ACCESS_KEY_ID": "your-key",
    "AWS_SECRET_ACCESS_KEY": "your-secret"
  }
}

Vertex AI:

{
  "claude-code.environmentVariables": {
    "CLAUDE_CODE_USE_VERTEX": "true",
    "ANTHROPIC_VERTEX_PROJECT_ID": "your-project-id",
    "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/credentials.json"
  }
}

Step 3: Configure Your Workspace

Recommended settings (add to .vscode/settings.json):

{
  "claude-code.autoAccept": false,  // Start safe, enable later
  "claude-code.showInlineDiffs": true,
  "claude-code.enablePlanReview": true,
  "editor.inlineSuggest.enabled": true
}

💡 Pro tip: Create a .vscode/settings.json in your project root so your team gets the same setup!

Extension Features Walkthrough

1. The Sidebar Panel (Your New Best Friend)

Click the ⚡ Spark icon to open Claude's panel. You'll see:

| Element | Purpose | Keyboard Shortcut | |---------|---------|-------------------| | 💬 Chat interface | Talk to Claude like normal | Cmd+Esc / Ctrl+Esc | | 📎 File attachments | Add files (or use @-mentions) | Click 📎 or drag files | | 🔍 Inline diffs | Changes highlighted in green/red | Auto-appears | | ✅❌ Accept/Reject buttons | Review each change individually | Click or keyboard nav | | 📑 Session tabs | Multiple conversations in parallel | Cmd+T / Ctrl+T |

💡 Pro tip: Drag the sidebar wider to see full diffs without scrolling.

2. Plan Review Mode (The Trust-But-Verify Approach)

When Claude proposes changes:

  1. 📋 Plan view appears first showing what Claude will do
  2. ✏️ Edit the plan if you want to adjust the approach
  3. ▶️ Click "Execute" when ready
  4. 👁️ Review diffs as they appear
  5. ✅❌ Accept or reject each file change

This is perfect for complex refactors where you want to sanity-check before execution.

3. Auto-Accept Mode (The YOLO Approach)

Enable in settings:

{
  "claude-code.autoAccept": true
}

Now Claude's changes apply immediately. Sounds scary? It is at first. But:

  • ✅ You still have Git to revert
  • ✅ Changes appear in real-time (you're watching)
  • ✅ 10x faster for routine tasks

When to use auto-accept:

| Scenario | Risk Level | Recommendation | |----------|------------|----------------| | 🔄 Routine refactors | 🟢 Low | ✅ Safe to enable | | ✅ Test generation | 🟢 Low | ✅ Safe to enable | | 📚 Documentation updates | 🟢 Low | ✅ Safe to enable | | 🏗️ Production-critical code | 🔴 High | ❌ Keep disabled | | 🆕 Unfamiliar codebases | 🟡 Medium | ❌ Review first | | 🏛️ Complex architecture changes | 🔴 High | ❌ Keep disabled | | 😴 3 AM sleep-deprived coding | 🔴 High | ❌ Trust me on this |

4. File Management

Add files to context:

| Method | How | When to Use | |--------|-----|-------------| | @-mentions | Type @filename in chat | Quick specific files | | Drag & drop | Drag files into chat | Multiple files at once | | System picker | Click 📎 icon | Browse file tree | | Current selection | Auto-shared if text selected | For code snippets |

Reference specific lines:

@src/auth.js#L45-67

Claude will focus on just those lines.

5. MCP Server Integration

If you've configured Model Context Protocol servers in your Claude CLI setup, they're automatically available in the extension!

Check Settings → Claude Code → MCP Servers to see active integrations.

6. Conversation History

Click the 📚 history icon to see all previous sessions. You can:

  • Resume old conversations
  • Search by keywords
  • Export chats for documentation

Legacy Terminal Integration

Before the extension, Claude CLI had killer terminal integration. It still does! And you'll use both.

Automatic IDE Connection

When you run claude from VS Code's integrated terminal, magic happens:

Features that activate:

| Feature | What Happens | Benefit | |---------|--------------|---------| | 📝 Selection context | Current selection auto-shared | No manual copying | | 👁️ IDE diff viewing | Changes show in VS Code diff editor | Visual comparison | | ⌨️ File shortcuts | Cmd+Option+K / Alt+Ctrl+K to reference files | One-key file adding | | 🐛 Diagnostic sharing | Lint errors automatically sent to Claude | Context-aware fixes |

External Terminal Connection

Using iTerm, Alacritty, or another terminal? Connect it:

claude
> /ide

This links your external terminal to VS Code. Now you get the same integration features!

Extension vs Terminal: The Decision Matrix

| Use Case | Extension | Terminal | Why | |----------|-----------|----------|-----| | 👁️ Visual diff viewing | ✅ Best | ❌ Text only | GUI advantage | | 📋 Plan review mode | ✅ Best | ❌ Limited | Interactive editing | | 🔀 Multiple session tabs | ✅ Best | ⚠️ Complex | Tab management | | 📎 Easy file attachment | ✅ Best | ⚠️ Manual | Drag & drop | | 🎯 Checkpoint features | ❌ N/A | ✅ Best | CLI exclusive | | 🤖 Subagents | ❌ N/A | ✅ Best | CLI exclusive | | 🔧 Advanced shortcuts (#, !) | ❌ N/A | ✅ Best | CLI exclusive | | ⌨️ Tab completion | ❌ N/A | ✅ Best | CLI exclusive | | 📜 Scripting and automation | ❌ N/A | ✅ Best | Bash integration |

Extension vs Terminal Comparison Choosing between extension and terminal? Use both for maximum productivity!

💡 Pro move: Use both! Extension for interactive development, terminal for automation.

Keyboard Shortcuts That'll Save Your Life

The Essential 5 (Commit These to Memory)

| Shortcut | Mac | Windows/Linux | What It Does | Why You'll Love It | |----------|-----|---------------|--------------|-------------------| | 🚀 Launch Claude | Cmd+Esc | Ctrl+Esc | Opens Claude panel from anywhere | Never touch mouse | | 📎 Add file reference | Cmd+Option+K | Alt+Ctrl+K | Instantly adds current file to context | One-key context | | 🎨 Command Palette | Cmd+Shift+P | Ctrl+Shift+P | Search all Claude commands | Discover features | | ⏹️ Cancel operation | Escape | Escape | Stop current task (not Ctrl+C!) | Stay in Claude | | 🔍 Search history | Ctrl+R | Ctrl+R | Find previous prompts | Reuse commands |

Terminal Control Shortcuts

Cancel current operation:

Escape (NOT Ctrl+C, which exits!)

Access previous messages:

Escape (twice quickly)

Search prompt history:

Ctrl+R

Like bash history search, but for your Claude prompts!

Navigate history:

Up/Down arrows

Exit Claude:

Ctrl+D

File Reference Tricks

Wrong way (opens new tab):

[Dragging file normally into chat]

Right way (adds to context):

Shift+Drag file into chat

Paste images:

Ctrl+V (NOT Cmd+V on Mac!)

🎯 Quick Challenge: Before reading the next section, can you recall the 5 essential shortcuts?

<details> <summary>Click to reveal the Essential 5</summary>
  1. Launch Claude: Cmd+Esc / Ctrl+Esc
  2. Add file: Cmd+Option+K / Alt+Ctrl+K
  3. Command Palette: Cmd+Shift+P / Ctrl+Shift+P
  4. Cancel: Escape
  5. Search history: Ctrl+R
</details>

Advanced Workflows: Running Multiple Instances

Here's where things get spicy. You can run multiple Claude instances in parallel.

The Parallel Workflow

Scenario: Building a full-stack feature

Terminal 1 - Backend:

claude --dangerously-skip-permissions
> Build REST API endpoints for user authentication
> POST /login, POST /register, GET /profile
> Use Express + JWT

Terminal 2 - Frontend:

claude --dangerously-skip-permissions
> Create React login form component
> Use the API endpoints at localhost:3000/api
> Include form validation

Terminal 3 - Tests:

claude --dangerously-skip-permissions
> Generate integration tests for auth endpoints
> Use Jest + Supertest
> Cover happy path and error cases

All three run simultaneously. While one's thinking, the others are working.

Message Queuing

Claude can queue messages while working:

# Claude is currently refactoring auth.js...
# You type:
> Now write tests for the auth module
[hit Enter]

# Claude finishes refactor, then immediately starts on tests

No waiting! Queue your next task and keep moving.

Parallel Instances: Decision Guide

| Use Case | Parallel? | Why | |----------|-----------|-----| | 🏗️ Frontend + backend development | ✅ Yes | Independent codebases | | 📝 Code + tests + documentation | ✅ Yes | Different file sets | | 🔄 Multiple microservices | ✅ Yes | Separate concerns | | 🌿 Different feature branches | ✅ Yes | No file conflicts | | 📄 Same files | ❌ No | Merge conflicts! | | ⏭️ Dependent tasks (finish A before B) | ❌ No | Sequence matters | | 😵 When you're confused | ❌ No | One thing at a time |

Parallel Workflow Example Running three Claude instances in parallel - backend, frontend, and tests simultaneously

VS Code Tasks Integration

VS Code tasks let you run Claude with one keyboard shortcut. Let's set it up.

Creating Claude Tasks

Create .vscode/tasks.json in your project:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Claude: Review Current File",
      "type": "shell",
      "command": "claude",
      "args": [
        "-p",
        "Review this code for bugs, performance issues, and best practices:\\n\\n$(cat ${file})"
      ],
      "problemMatcher": [],
      "presentation": {
        "reveal": "always",
        "panel": "new"
      }
    },
    {
      "label": "Claude: Generate Tests",
      "type": "shell",
      "command": "claude",
      "args": [
        "-p",
        "Generate comprehensive unit tests for:\\n\\n$(cat ${file})"
      ]
    },
    {
      "label": "Claude: Explain Code",
      "type": "shell",
      "command": "claude",
      "args": [
        "-p",
        "Explain this code in simple terms:\\n\\n$(cat ${file})"
      ]
    },
    {
      "label": "Claude: Add Documentation",
      "type": "shell",
      "command": "claude",
      "args": [
        "-p",
        "Add JSDoc comments to all functions:\\n\\n$(cat ${file})"
      ]
    },
    {
      "label": "Claude: Refactor for Performance",
      "type": "shell",
      "command": "claude",
      "args": [
        "-p",
        "Refactor for better performance, maintain functionality:\\n\\n$(cat ${file})"
      ]
    }
  ]
}

The 5 Essential Tasks

| Task | What It Does | When to Use | Keyboard Shortcut | |------|--------------|-------------|-------------------| | 🔍 Review Current File | Scans for bugs, performance issues, best practices | Before commits | Cmd+Shift+R | | ✅ Generate Tests | Creates comprehensive unit tests | After writing features | Cmd+Shift+T | | 📖 Explain Code | Simplifies complex code | Code reviews, onboarding | Cmd+Shift+E | | 📚 Add Documentation | Generates JSDoc comments | Public APIs, libraries | Cmd+Shift+D | | ⚡ Refactor for Performance | Optimizes while maintaining functionality | Performance tuning | Cmd+Shift+P |

Running Tasks

Via Command Palette:

  1. Cmd+Shift+P / Ctrl+Shift+P
  2. Type "Tasks: Run Task"
  3. Select your Claude task

Via Keyboard Shortcut:

Add to .vscode/keybindings.json:

[
  {
    "key": "cmd+shift+r",
    "command": "workbench.action.tasks.runTask",
    "args": "Claude: Review Current File"
  },
  {
    "key": "cmd+shift+t",
    "command": "workbench.action.tasks.runTask",
    "args": "Claude: Generate Tests"
  }
]

Now Cmd+Shift+R reviews current file instantly!

Pre-Commit Task Automation

Add a git hook that runs Claude before commits:

.git/hooks/pre-commit:

#!/bin/bash

# Run Claude review on staged files
staged_files=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(js|ts|py)$')

if [ -n "$staged_files" ]; then
  echo "Running Claude review..."
  for file in $staged_files; do
    claude -p "Quick review for obvious bugs: $(cat $file)" > /tmp/claude-review.txt
    if grep -q "CRITICAL\\|SEVERE\\|BUG" /tmp/claude-review.txt; then
      echo "⚠️  Claude found issues in $file"
      cat /tmp/claude-review.txt
      read -p "Continue commit anyway? (y/n) " -n 1 -r
      echo
      if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        exit 1
      fi
    fi
  done
fi

Make it executable:

chmod +x .git/hooks/pre-commit

Now Claude reviews every commit automatically!

Pro Tips from the Trenches

These tips come from real developers using Claude Code in production. Let's learn from their pain (so you don't experience it).

1. Skip Permissions Mode

The Problem:

$ claude "fix bug"
✓ Allow Claude to read src/app.js? (y/n)
✓ Allow Claude to write src/app.js? (y/n)
✓ Allow Claude to read package.json? (y/n)
# 😫 10 prompts later...

The Solution:

claude --dangerously-skip-permissions

Make it permanent with an alias in ~/.bashrc or ~/.zshrc:

alias cc='claude --dangerously-skip-permissions'

Now just type cc and go!

🔒 Security note: Only use in repos you trust. For sensitive projects, keep permissions enabled.

2. Use CLAUDE.md for Context

Create .claude/CLAUDE.md in your project:

# Project Context for Claude

## Stack
- Node.js 20.x
- React 18 + TypeScript
- PostgreSQL 15
- Deployed on AWS ECS

## Commands
- Build: `npm run build`
- Test: `npm test`
- Dev server: `npm run dev`

## Conventions
- Use named exports, not default
- Async functions must have try/catch
- All API responses follow JSON:API spec
- Test files: `*.test.ts` (same directory as source)

## Current Sprint
Working on user authentication system.
Do not modify payment processing code.

Claude reads this automatically! No more repeating yourself every session.

3. The /clear Command

Use it liberally:

> /clear

Clears conversation context and saves tokens. Use after:

  • ✅ Completing a task
  • ✅ Switching features
  • ✅ When Claude seems confused
  • ✅ Every 30 minutes of heavy usage

💡 Pro tip: Create a habit - /clear between tasks like saving files between edits.

4. Shift+Enter for Multi-line Input

By default, Enter sends your message. For multi-line prompts:

First, run once:

> /terminal-setup

Now Shift+Enter works!

> Refactor this function to:
[Shift+Enter]
> 1. Use async/await instead of callbacks
[Shift+Enter]
> 2. Add error handling
[Shift+Enter]
> 3. Extract validation logic
[Enter to send]

5. Make Claude Your Primary Interface

Old workflow (slow):

  1. Write code in editor
  2. Ask Claude to review
  3. Switch back to editor
  4. Make changes
  5. Repeat

New workflow (fast):

  1. Ask Claude to implement feature
  2. Review changes in IDE diff view
  3. Accept or tweak
  4. Done

Let Claude write, you review. It's faster.

6. GitHub Integration

One-time setup:

> /install-github-app

Now Claude can:

  • 📝 Review PRs automatically
  • ✍️ Generate PR descriptions
  • 🔍 Analyze issues
  • 💡 Suggest fixes

Customize reviews by creating .claude/github-review-config.md:

Focus on:
- Security vulnerabilities
- Breaking changes
- Performance regressions

Ignore:
- Code style (we have Prettier)
- Minor naming
- Comment formatting

7. The Escape Key (Not Ctrl+C!)

| Key | What Happens | When to Use | |-----|--------------|-------------| | ❌ Ctrl+C | Exits Claude entirely | 💀 Never during tasks | | ✅ Escape | Stops current task, stays in Claude | ⏸️ Always for canceling | | 🔄 Escape (twice) | See previous messages | 📜 Review history |

Bonus: Press Escape twice to see previous messages.

8. Searchable History

Find that perfect prompt from yesterday:

Ctrl+R
(search): refactor

Just like bash history search! Navigate results with Ctrl+R / Ctrl+S.

Real-World Workflow Examples

Example 1: Full-Stack Feature Development

Goal: Add "Forgot Password" feature

Setup:

  • 📋 Extension: Planning and reviewing
  • 🔧 Terminal 1: Backend implementation
  • ⚛️ Terminal 2: Frontend implementation
  • ✅ Terminal 3: Test generation

Extension (Planning):

Plan the forgot password flow:
1. User requests reset
2. Email sent with token
3. User clicks link, resets password
4. Session invalidated

Show me the steps for backend and frontend.

Terminal 1 (Backend):

cc

> Implement password reset API:
> POST /api/password/request-reset (email)
> POST /api/password/reset (token, new password)
>
> Use nodemailer for emails
> Store tokens in Redis with 1h expiration
> Hash passwords with bcrypt
>
> Files: @src/routes/auth.js @src/services/email.js

Terminal 2 (Frontend):

cc

> Create password reset flow:
> 1. RequestResetForm component (email input)
> 2. ResetPasswordForm component (token from URL, password inputs)
> 3. Add routes to App.js
>
> Use Formik + Yup for validation
> Show success/error toasts
>
> Files: @src/components/auth/

Terminal 3 (Tests):

cc

> Generate integration tests for password reset:
> - Request reset (valid/invalid email)
> - Reset with valid token
> - Reset with expired token
> - Reset with used token
>
> Use Jest + Supertest
> Mock nodemailer

Review in extension: Accept changes, tweak as needed, profit!

Example 2: Debugging Production Issue

Scenario: Users reporting 500 errors on checkout

Workflow:

| Step | Tool | Action | Duration | |------|------|--------|----------| | 1️⃣ | Terminal | Analyze logs for patterns | 2 min | | 2️⃣ | Extension | Review suspicious code with diff view | 3 min | | 3️⃣ | Extension | Fix with auto-accept enabled | 5 min | | 4️⃣ | Terminal | Generate regression test | 3 min | | 5️⃣ | Task | Verify fix (keyboard shortcut) | 2 min |

Step 1: Analyze logs (Terminal)

cc

> Analyze these error logs for patterns:
> $(cat /var/log/app/error.log | tail -100)

Step 2: Review suspicious code (Extension with diff view)

Based on the logs, review @src/checkout/payment.js
Focus on the Stripe integration around line 145.
Look for race conditions or missing error handling.

Step 3: Fix and test (Extension with auto-accept enabled)

Fix the race condition you identified.
Add proper error handling.
Include retry logic for network failures.

Step 4: Generate regression test (Terminal)

> Create a test that reproduces the race condition
> and verifies the fix works

Step 5: Verify fix (Tasks)

# Run via keyboard shortcut: Cmd+Shift+T
# Task runs: npm test -- payment.test.js

Total time: 15 minutes (vs 2 hours of manual debugging).

Example 3: Code Review Before PR

Task: Review 500 lines of changes across 8 files

Using VS Code task:

# Keyboard shortcut: Cmd+Shift+R
# Runs "Claude: Review Current File" for each staged file

For full PR review:

cc

> Review this PR for:
> - Breaking changes
> - Security issues
> - Performance problems
> - Missing tests
>
> Changed files:
> $(git diff --name-only origin/main)
>
> Here's the full diff:
> $(git diff origin/main)

Claude outputs a comprehensive review you can paste into GitHub!

FAQ

Is the VS Code extension free?

The extension itself is free, but you need a Claude Code account:

  • Free tier: Limited usage with rate limits
  • Pro tier: Higher limits, priority access
  • Enterprise: Unlimited with Bedrock/Vertex AI

Can I use Claude CLI without the extension?

Absolutely! The terminal integration works great standalone. The extension just adds the visual diff UI and some convenience features.

How do I set up custom keyboard shortcuts?

  1. Open Keyboard Shortcuts: Cmd+K Cmd+S / Ctrl+K Ctrl+S
  2. Search for "Claude"
  3. Click the + icon next to any command
  4. Press your desired shortcut
  5. Done!

Or edit .vscode/keybindings.json directly (see the Tasks section above).

Does this work with Cursor, Windsurf, or other VS Code forks?

Yes! The extension works with:

  • ✅ Visual Studio Code
  • ✅ Cursor
  • ✅ Windsurf
  • ✅ VSCodium

All VS Code-compatible editors are supported.

What's the difference between the extension and terminal integration?

| Aspect | Extension | Terminal | |--------|-----------|----------| | Interface | GUI (sidebar, diffs, buttons) | CLI (text interface) | | Best for | Interactive development | Automation | | Unique features | Plan review, auto-accept, session tabs | Checkpoints, subagents, advanced shortcuts | | File handling | Drag & drop, @-mentions | File paths, bash piping | | Learning curve | Easier (visual) | Steeper (command-based) | | Scriptable | Limited | Fully scriptable |

Use both! They complement each other.

How do I use third-party providers (Bedrock/Vertex)?

See the "Installation & Setup" section above for environment variable configuration. You can use AWS Bedrock or Google Vertex AI instead of Anthropic's API.

Can I run Claude Code in a remote SSH session via VS Code?

Yes! If you're using VS Code Remote SSH:

  1. Install the extension on the remote server
  2. Authenticate as usual
  3. Works exactly the same

How do I avoid token limit issues?

| Strategy | How | Impact | |----------|-----|--------| | Clear context | Use /clear frequently | High | | Focus files | Only attach relevant files | High | | Custom commands | Reusable prompts = less token overhead | Medium | | Auto-accept | Faster = fewer tokens | Medium | | Monitor usage | Settings → Claude Code → Usage Stats | Awareness |

Conclusion

You now have Claude Code fully integrated into VS Code:

  • ✅ Native extension with real-time diffs
  • ✅ Keyboard shortcuts for mouseless workflows
  • ✅ Multiple parallel instances for simultaneous development
  • ✅ VS Code tasks for one-click operations
  • ✅ Pro tips from real developers in production

Your Homework (5 Tasks)

| Task | Difficulty | Time | Impact | |------|------------|------|--------| | 1️⃣ Install VS Code extension | 🟢 Easy | 5 min | High | | 2️⃣ Set up 3 VS Code tasks | 🟡 Medium | 15 min | High | | 3️⃣ Create cc alias with permission-skip | 🟢 Easy | 2 min | High | | 4️⃣ Try 2 parallel Claude instances | 🟡 Medium | 30 min | Medium | | 5️⃣ Add CLAUDE.md to your project | 🟢 Easy | 10 min | Medium |

Coming up next: In "Claude CLI Advanced Features: Checkpoints, Subagents, and Power User Secrets", we'll dive into:

  • 🎯 Checkpoints for safe refactoring (save points before big changes!)
  • 🤖 Subagents for specialized tasks (code review agent, test agent, docs agent)
  • 🔄 Background tasks for long-running operations
  • 🪝 Hooks for automating workflows
  • 🔌 MCP server configuration for custom tools

Ready to level up? Try this challenge:

Build a complete CRUD feature using only VS Code tasks and parallel Claude instances. Time yourself. Then tell us: How long did it take vs doing it manually?

👈 Previous: Custom Commands Guide 👉 Next: Advanced Features: Checkpoints & Subagents

P.S. If you're still using Ctrl+C to stop Claude instead of Escape, we can't be friends. Just kidding. But seriously, use Escape.