+170 XP

Claude · Plugins and ecosystem integrations

Claude does its best work inside the tool you already have open, not in a browser tab you keep switching to. This lesson maps every place Claude plugs in: your editor, your desktop, your Slack, your repos, and the connector layer that ties them together. Then we set up the VS Code integration end to end, package it as a plugin your team can install, and draw a clear line for when an integration earns its keep over copy-paste.

The integration surface, mapped

Think of Claude as having three "bodies" you can install it into.

The Claude apps. Web, desktop, and mobile share the same core: Projects (persistent context buckets), Artifacts (live, editable outputs), Styles (reusable tone and format presets), and Skills (packaged instructions plus files Claude loads on demand). The desktop app matters most here because it can run Connectors and local MCP servers, which the web app cannot reach.

Claude Code. A terminal-native agent that reads and edits your actual filesystem, runs commands, and works against your git history. This is what powers the IDE extensions, and it is where plugins live.

The API layer. The Anthropic Messages API and the Claude Agent SDK, for when you build your own surface instead of using Anthropic's.

The connective tissue across all three is MCP (Model Context Protocol), an open standard for exposing tools and data to a model. A "Connector" in the Claude apps is, under the hood, usually an MCP server. Learn MCP once and the same mental model applies in the desktop app, Claude Code, or your own SDK build. The spec lives at modelcontextprotocol.io.

Connectors and the directory

A Connector lets Claude read from and act on an external system: your Google Drive, a Notion workspace, a Postgres database, a Sentry project. Anthropic ships first-party connectors and hosts a connector directory. Many entries are community-built MCP servers you point Claude at.

Two flavors matter:

  • Remote connectors (hosted, OAuth-based) work in the web and desktop apps. Good for SaaS tools.
  • Local MCP servers run on your machine and require the desktop app or Claude Code. Good for local files, databases, and internal tools you don't want exposed to the internet.

That distinction decides which body of Claude you reach for. Local data means desktop or Claude Code, not the web app.

Setting up the VS Code integration

Let's do the concrete one. The Claude Code extension brings the agent into VS Code so it can see your open files, your selection, and your diagnostics, then propose edits you review inline.

Install

Install the Claude Code CLI. The extension wires into it.

bash
# Install Claude Code (macOS / Linux)
curl -fsSL https://claude.ai/install.sh | bash

# Verify, then authenticate
claude --version
claude   # first run opens a browser to log in

Then in VS Code, open the Extensions panel, search Claude Code, and install the official Anthropic extension. JetBrains users get a parallel plugin from the JetBrains Marketplace, and the workflow below is nearly identical.

Once installed, you get a Claude panel in the sidebar and a shortcut to send the current selection or file into context. The key difference from the web app: Claude sees the real project, not a pasted snippet. It can open neighboring files, read your package.json, and run your test command.

Scope it with a project config

Drop a CLAUDE.md file at your repo root. These are the project's standing instructions, loaded automatically every session. It's the single highest-leverage file in the whole setup.

markdown
# Project: billing-service

## Stack
- TypeScript, Node 20, Fastify, Prisma, Postgres
- Tests: vitest. Run with `npm test`.

## Conventions
- No `any`. Prefer explicit return types on exported functions.
- All money values are integer cents, never floats.
- DB access goes through `src/db/`, never inline Prisma in routes.

## Before you finish
- Run `npm run lint && npm test` and report results.

Now when you ask "add a refund endpoint," Claude already knows your stack, your money rule, and that it should run lint and tests before declaring victory. You stop re-explaining context on every prompt.

Add a local MCP server

Say you want Claude to query your dev database from inside VS Code. Register an MCP server for the project. The original reference Postgres server from the MCP project is archived, so use a maintained one such as DBHub:

bash
claude mcp add postgres-dev -- \
  npx -y @bytebase/dbhub --transport stdio \
  --dsn "postgres://localhost:5432/billing_dev"

After this, "show me the schema of the invoices table and write a migration to add a refunded_at column" works against your live dev schema. You don't have to paste \d invoices output. The server runs locally, so the connection string never leaves your machine. Run claude mcp list to confirm it connected.

Claude Code in VS Code: Full Setup & Workflow

Watch on YouTube

Plugins: package the setup once, share it everywhere

Everything above is per-repo, per-person configuration. Claude Code plugins bundle it so a teammate gets the same setup with one command. A plugin can contain any mix of:

  • slash commands (/review-money, /new-endpoint)
  • subagents with their own instructions and tool limits
  • hooks that run at fixed points, such as running the linter after every edit
  • Skills
  • MCP server definitions, like the database server above

Plugins are distributed through marketplaces, which are just git repos with a manifest. Inside a Claude Code session:

text
/plugin marketplace add your-org/claude-plugins
/plugin install billing-tools@your-org

Run /plugin on its own to browse, enable, or disable what's installed. Anthropic and the community publish public marketplaces on GitHub, and a company can host a private one for internal tools.

The rule of thumb: if you've copied the same commands or MCP config into a third repo, turn it into a plugin. Keep CLAUDE.md for what's specific to one project, like its stack and conventions.

The GitHub integration

The GitHub integration moves Claude from your editor into your pipeline. Install the Claude GitHub app on a repo and you can tag @claude in an issue or PR comment. It will open a branch, write the change, and push a PR, or review an existing PR and leave inline comments.

This is the cleanest example of an integration beating the web app. The model acts where the work already lives: the diff, the CI logs, the review thread. Nothing gets pasted anywhere. You wire it up with a GitHub Actions workflow and your Anthropic API key stored as a repo secret. Use it for triaging issues, drafting first-pass PRs for well-specified tickets, and automated review on a label.

Slack and team surfaces

The Claude Slack integration puts Claude in a channel or DM. There it can read the thread it's mentioned in and answer using your connected context. Pair it with a Notion or Drive connector and "@Claude summarize the decision in this thread and draft the update for #eng-announce" becomes a one-message task.

The pattern generalizes. Any surface where your team already talks or works is a candidate. The model is the same everywhere. The value comes from removing the context-gathering step a person would otherwise do by hand.

Knowledge check

1. What is the primary role of MCP (Model Context Protocol) across Claude's different surfaces?

2. You need Claude to read and act on a local Postgres database and internal files you don't want exposed to the internet. Which surface should you reach for?

3. Why does the desktop app matter more than the web app when working with certain integrations?

MULTIPLE CHOICE

4. Select ALL statements that correctly describe the distinction between remote connectors and local MCP servers.

Select all the correct answers.

MULTIPLE CHOICE

5. Select ALL of the following that are shared capabilities of the Claude apps (web, desktop, mobile).

Select all the correct answers.

When an integration beats copy-paste

The web app is a great scratchpad. An integration wins whenever one of these is true:

1. The context is large or lives in many files. Pasting twelve files into a chat is lossy, and you'll forget one. The IDE integration reads the repo. Assembling context by hand is exactly the cost the integration deletes.

2. The output needs to land somewhere specific. A PR, a Slack message, a database row, an edited file. If you're going to copy Claude's answer into another tool, an integration that writes there directly removes a failure point. That copy-paste step is where formatting gets lost or the wrong block gets grabbed.

3. The task is repeated. "Review every PR for our money-handling rule" is worth a GitHub Action or a plugin command. A one-off question is not. Automate the loop, not the one-off.

4. The data can't leave your machine or your org. Local MCP servers and the desktop app keep things in-house. The web app means data transits through your browser session.

When none of those hold (a quick question, a brainstorm, a snippet small enough to paste), the web app is the right tool. Don't over-engineer. Config files, auth, and MCP servers are overhead, and that overhead only pays off when context, destination, repetition, or data residency is in play.

A worked comparison

You need to add input validation to one route.

  • Copy-paste path: paste the route, paste the schema file, paste the validation library's docs, and describe the convention. Then copy the answer back, fix the import path it guessed wrong, and run the tests yourself.
  • VS Code integration path: "add validation to the POST /refunds route per our conventions." Claude reads the route, the schema, and CLAUDE.md. It writes the edit with correct imports, runs npm test, and reports back. You review the diff.

The second path uses the same model. The difference is the friction removed.

Building your own surface

When no existing integration fits, you build one with the Agent SDK. This is the escape hatch: you keep Claude's tool use and MCP capabilities but wrap them in your own app, cron job, or internal service.

python
import anthropic

client = anthropic.Anthropic()

resp = client.messages.create(
    model="claude-sonnet-4-5",  # check the models page for the current ID
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": "Summarize today's failed payments and flag any over $500.",
    }],
)
print(resp.content[0].text)

That's the raw Messages API. The Agent SDK (Python and TypeScript) builds on top of it. It gives you the same agent loop, tool calling, and MCP support that Claude Code uses, so a nightly script can do what you'd otherwise do by hand in the app. Examples and SDK source live under github.com/anthropics.

The mental model: apps for thinking, Claude Code and IDE extensions for building, plugins for sharing that setup, and the SDK for shipping the loop into your own infrastructure. MCP is the wire that connects your tools to all of them.

Key Takeaways

  • Match the surface to the data. Remote SaaS connectors work in the web app. Local files and databases require the desktop app or Claude Code.
  • Write a CLAUDE.md for every repo. It removes the context you'd otherwise re-type every prompt.
  • Once a setup repeats across repos, package the commands, subagents, hooks, and MCP servers as a plugin and install it with /plugin.
  • Use the four-part rule (large context, specific destination, repeated task, data that can't leave) to choose between an integration and the web app. If none apply, use the web app.
  • Reach for the GitHub and Slack integrations when the work already lives in a PR or a thread, so Claude acts in place.
  • Learn MCP once. The same protocol underlies connectors, Claude Code servers, plugins, and your own Agent SDK builds.

What to do, from this lesson

These actions are compiled in the role's Playbook.

  • Add a CLAUDE.md with test command, conventions, and off-limits directories
See the full action playbook →