# 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:

```bash
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**](08-lab-3-mcp.md).