v10

Section 3 — IDE Integration + MCP Ecosystem

Summary — what this page covers Moving Claude Code from the terminal into the full dev environment, then connecting it to the outside world via MCP. This is where the "operate Claude Code from the terminal, VS Code, and JetBrains" outcome is completed: attendees run the same agent inside VS Code and JetBrains (Rider/IntelliJ), manage sessions across surfaces, learn the MCP architecture, and drive the GitHub MCP server live. This is also the conceptual foundation for Day 2's "build an MCP server in C#." Pair with Lab 3.

1:30 – 3:15 PM · 105 min — 40 min lecture/demo + 65 min lab

Learning objectives

  • Operate Claude Code across all three surfaces — terminal (from Section 1), VS Code, and JetBrains — and know what's the same and what differs between them

  • Use Claude Code inside VS Code with full IDE integration (inline diffs, context sharing, permission UI)

  • Configure and use the JetBrains plugin — Rider (the .NET-native choice), IntelliJ, others

  • Manage sessions across environments (--continue, --resume, /desktop, /teleport, plan mode)

  • Explain the Model Context Protocol (host / client / server; tools / resources / prompts)

  • Configure and use the GitHub MCP server

  • Understand the 10,000+ server MCP ecosystem

Content

Block 3A — IDE integration (≈40 min)

Frame first: it's the same agent everywhere. The model, your conversation, and your .claude/ config (CLAUDE.md, rules, skills, hooks) are identical across the terminal, VS Code, and JetBrains — they travel with the repo. What changes between surfaces is only the diff review and permission UI: where you approve edits and how you see changes. Nothing you built in Labs 1–2 has to be redone; it just renders differently.

VS Code. Install the extension and run the same agent inside the editor:

code --install-extension anthropic.claude-code

  • Inline diff review — Claude's edits appear as diffs you approve / reject / modify right in the editor, instead of a terminal patch.

  • "Add to Claude Code context" — select code in a file and push it straight into the session, so you don't have to describe where something lives.

  • Clickable permission UI — the approve/deny prompts from Section 1 become buttons.

JetBrains. Install "Claude Code" from the Marketplace and restart the IDE after installing. It works across the JetBrains family — Rider (the .NET-native IDE — the natural choice for this audience), IntelliJ, PyCharm, WebStorm. The key difference from VS Code: diff review uses the JetBrains merge tool rather than an inline diff.

Session management (cross-surface). Your work isn't trapped in one window:

  • claude --continue — resume your most recent session.

  • claude --resume <id> — resume a specific session by id.

  • /desktop and /teleport — move the current session to the desktop app / another surface so you can pick up where you left off.

  • Plan mode (--plan, /plan) — have Claude produce a plan and wait for your approval before it acts. Use it for large or destructive operations where you want to review the approach first.

Outcome check: by the end of Block 3A every attendee should have run the same task in the terminal and in their IDE (VS Code or Rider) and seen the diff/permission flow in each.

Block 3B — MCP architecture (≈50 min)

The N×M problem MCP solves. Without a standard, connecting M AI hosts to N tools/services means writing M × N custom integrations — every host needs bespoke glue for every service. The Model Context Protocol (MCP) is the common interface — think "USB-C for AI tools" — so any host can talk to any server through one protocol. M + N, not M × N.

Host / client / server. Three roles:

  • Host — the app you run (Claude Code, Claude Desktop). It's where you work.
  • Client — the connector inside the host that speaks MCP to one server.
  • Server — a separate process that exposes capabilities (e.g. GitHub, a database). One host can connect to many servers at once.

Primitives — what a server exposes:

  • Tools — functions Claude can call to take action (create an issue, run a query).
  • Resources — readable data the server makes available (files, records).
  • Prompts — reusable templates the server offers.

GitHub MCP server — live demo. Configure the GitHub MCP server, then run a prompt sequence that queries the repo (issues, PRs) and ends by creating an issue through Claude. This is the exact pattern you'll do hands-on in Lab 3.

⚠️ High-risk / internet-dependent demo — have the recorded backup ready in case the network or GitHub is uncooperative.

Why this matters for Day 2. Today you use an MCP server someone else built. In Day 2 Section 4, you'll build your own MCP server in C# to connect Claude to the BookTracker database — this is the conceptual groundwork for that.

Steering tie-in: MCP gives Claude the tools; a skill can teach Claude how to use them well — the server's schema, the good query patterns, the gotchas. Tools and steering are complementary, not competing.

Demos referenced here

  • GitHub MCP Server (High risk · internet-dependent — have the recorded backup ready).

→ Continue to Lab 3.