← Home | Module 04 — Cowork Plugins
0%
Module 04 · Live

Cowork Plugins — Connect Everything

Plugins give Claude access to your real tools — Notion, Linear, GitHub, Figma, Jira, and more. Instead of switching apps constantly, Claude reads from and writes to your actual workspace. Your AI finally has context.

~40 min
🏗 Project: connected workflow
🔌 Requires: at least one tool account

🔌 What Are Cowork Plugins?

Before plugins, Claude only knew what you told it in a prompt or what lived in your local files. Plugins change that — they connect Claude directly to the tools your team already uses, giving it read and write access to your real data.

WITHOUT PLUGINS
  • Copy ticket from Linear → paste into Claude
  • Copy Claude's answer → paste back into Notion
  • Switch to GitHub → copy PR description → come back
  • Claude has no idea what your team is working on
  • Every session starts from zero context
WITH PLUGINS
  • "Read my Linear backlog and prioritize it"
  • "Create a Notion page from this meeting summary"
  • "Open a GitHub PR for the branch I just committed"
  • Claude understands your live project state
  • Actions happen directly — no copy-paste
The big shift: Plugins turn Claude from a smart text generator into an active participant in your workflow. It can read your tasks, update your docs, and create issues — while you describe what you want in plain English.

⚙️ MCP — The Protocol Behind Plugins

Plugins are built on MCP (Model Context Protocol) — an open standard created by Anthropic that defines how AI models communicate with external tools. You don't need to understand the protocol deeply, but knowing the basic architecture helps you reason about what's possible.

🧠
Claude
The AI brain
🔌
MCP Server
The plugin layer
🛠
Your Tools
Notion, Linear, GitHub…
  • Claude receives your prompt and decides what action to take
  • The MCP server is a small program that translates Claude's intent into API calls for the connected tool
  • Your tool (Notion, Linear, GitHub, etc.) receives the request and returns data or confirms the action
Security note: Each plugin uses OAuth (the same "Sign in with Google" standard) to authenticate. Claude never sees your password — it gets a scoped access token that can only do what you explicitly authorized.

What plugins can do (and can't do)

✓ Can do
  • Read pages, issues, tickets, repos
  • Create new items (issues, pages, PRs)
  • Update existing content
  • Search and filter your data
  • Cross-reference between tools
✗ Can't do
  • Access data you haven't authorized
  • Delete items without your confirmation
  • Share data with third parties
  • Act on tools you haven't connected

🔗 Connecting Your First Plugin

Connecting a plugin is a one-time setup per tool. After that, it's available in every Claude Code session. Here's the exact process:

1
Open the Cowork plugin registry In your Claude Code session, type /config to open settings, or navigate to the Cowork panel in your Claude desktop app. You'll see a list of available plugins.
2
Select the plugin you want Click the plugin (Notion, Linear, GitHub, etc.). Each plugin page shows exactly what permissions it needs and what it can do before you authorize anything.
3
Authorize via OAuth Click Connect. Your browser opens the tool's own login page (e.g., Notion's authorization screen). You approve the access — this grants Claude a scoped token, not your password.
4
Return to Claude and test it Once authorized, the plugin is live in your session. Test it immediately: "Using the Notion plugin, list the 3 most recently updated pages in my workspace."

Installing via the MCP config (advanced)

For developers or custom setups, plugins can also be added directly to the MCP configuration file. Claude Code stores this at ~/.claude/settings.json.

~/.claude/settings.json — MCP server entry
{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-notion"],
      "env": {
        "NOTION_API_KEY": "your-integration-token"
      }
    }
  }
}
Most users: Use the Cowork GUI to connect plugins — no config editing needed. The manual JSON approach is for developers who want to connect custom or self-hosted MCP servers.

📦 Plugins Catalog

These are the most-used plugins in the Cowork ecosystem. Each one gives Claude live read/write access to that tool.

Notion productivity
Docs & knowledge base

Read and write Notion pages and databases. Perfect for meeting notes, project wikis, and content management.

"Summarize the Q3 planning page in Notion"
"Create a new Notion page for today's standup"
Linear productivity
Issue tracking

Read and create Linear issues, update priorities, query backlogs, and link work to projects.

"Show my open Linear issues sorted by priority"
"Create a Linear issue: fix login bug, high priority"
GitHub dev
Code & repos

Read repos, create and review PRs, open issues, check CI status, and navigate codebases without leaving Claude.

"List open PRs in my-repo needing review"
"Create a GitHub issue for the login bug"
Atlassian productivity
Jira + Confluence

Access Jira tickets and Confluence docs. Create sprint tasks, update statuses, and pull wiki pages into context.

"Show all Jira tickets in the current sprint"
"Update PROJ-42 status to In Review"
Figma design
Design files

Read Figma files, extract design tokens (colors, typography, spacing), and generate code from component descriptions.

"Extract the color palette from my Figma file"
"Read the button component and generate CSS"
ClickUp productivity
Project management

Manage ClickUp tasks, spaces, and lists. Create tasks from natural language and pull status updates across projects.

"Show all overdue tasks in my ClickUp workspace"
"Create a task: review onboarding flow, due Friday"

💬 Using Plugins in Your Prompts

Once connected, you reference a plugin the same way you reference a file — just mention it naturally in your prompt. Claude figures out which plugin to use and what action to take.

Basic usage patterns

Claude prompts with plugins
# Read — pull data into the conversation
"Using Notion, read the page called 'Q4 Roadmap' and summarize
the top 3 priorities."

# Write — push Claude's output to your tool
"Create a new Linear issue: title 'Fix checkout flow timeout',
priority High, assign to backend team."

# Cross-reference — combine data from multiple sources
"Read the Figma color tokens from the design file, then update
styles.css in this project to match them exactly."

# Summarize and write — process then push
"Read my last 5 Linear issues, identify the common theme,
and create a Notion page summarizing the pattern with recommended fixes."

Being specific about which workspace or project

If you have multiple workspaces or projects in a tool, tell Claude which one. Vague references slow it down — it has to ask for clarification.

Vague vs. specific plugin prompts
❌ Vague
"Show me my issues"

✓ Specific
"In Linear, show all open issues in the 'Web App' project
assigned to me, sorted by priority."

❌ Vague
"Create a page in Notion"

✓ Specific
"In Notion, create a new page in the 'Engineering' workspace
called 'Week 17 Retrospective'. Use this template structure:
What went well / What didn't / Action items."
Pro pattern — plugin + local file: Read data from a plugin, transform it, and write the result back to a local file or another plugin. Example: "Read all open Linear issues from the current sprint, generate a daily standup summary, and save it as standup.md."

🔄 Multi-Plugin Workflows

The real unlock is combining plugins. Here are three ready-to-use workflows you can run today — each one replaces 20–30 minutes of manual work.

Workflow 1 — Meeting Notes → Action Items

📝
Paste raw meeting notes into ClaudeYou write or paste the notes — no formatting needed
📓
Claude creates a Notion page"Format these notes and save them as a Notion page in my 'Meetings' database"
📋
Claude creates Linear issues for each action item"Extract every action item from those notes and create a Linear issue for each one, assigned to the named person"

Workflow 2 — Bug Report → Tracked Issue

🐛
Describe the bug in plain EnglishNo ticket format needed — just explain what's broken
🐙
Claude creates a GitHub issue with full context"Create a GitHub issue in my-repo. Title: 'Login timeout on slow connections'. Include steps to reproduce and expected behavior."
📋
Claude creates a matching Linear ticket and links them"Create a corresponding Linear issue linked to that GitHub issue. Priority: High."

Workflow 3 — Design → Code → PR

🎨
Claude reads the Figma design tokens"Read the button component from the Figma file and extract colors, spacing, and typography"
💻
Claude updates the local CSS/component file"Update Button.css to match those exact Figma values — no other changes"
🐙
Claude opens a GitHub PR with a description"Create a GitHub PR for these changes. Title: 'Sync button styles with Figma design tokens'"
Save your workflows as prompts. Once you've built a multi-plugin workflow that works, paste the full prompt sequence into your CLAUDE.md under a "Workflows" section. One copy-paste and it runs again next time.
⌨️ Live Terminal Sandbox Interactive
Simulate plugin actions — see how Claude responds
claude
✓ Claude Code — ready · Module 04 sandbox
Connected plugins: notion · linear · github
 
Try plugin commands below.
 

🎯 Challenge — Connect and Use One Plugin

Pick any tool you use daily. Connect it and run three different operations in one session.

  1. 1 Connect one plugin via the Cowork panel or /config. Choose the tool you use most: Notion, Linear, GitHub, or ClickUp. Complete the OAuth flow until you see it listed as connected.
  2. 2 Run a read operation. Ask Claude to list, summarize, or describe something real from that tool. For example: "Show me the 5 most recently updated pages in my Notion workspace."
  3. 3 Run a write operation. Create something new using Claude. Example: "Create a new Linear issue titled 'Audit plugin performance' — priority Medium, no assignee."
  4. 4 Cross-reference with a local file. Ask Claude to read something from the plugin AND from a local file in the same prompt. Example: "Read my Linear backlog and compare it to the tasks in TASKS.md — what's missing from Linear?"

🏗 Mini Project — Build a Connected Workflow

You're going to build a real end-to-end workflow: write a project brief locally, push it to Notion, create Linear issues from it, and save the whole workflow prompt to your CLAUDE.md so you can rerun it instantly. Pick your OS.

Step 1 — Connect Notion and Linear (or pick two tools you have) This is a one-time setup. Skip to Step 2 if you've already connected these plugins.

Open your Claude desktop app or web interface. Find the Cowork section (usually in the left sidebar or under Settings). You'll see the plugin registry.

Connect both Notion and Linear:

  • Click the plugin → click Connect
  • Your browser opens the tool's own authorization page
  • Click Allow or Authorize — you're granting read/write access
  • Return to Claude — the plugin shows as connected
Don't have Notion or Linear? Both have free plans. Sign up at notion.so and linear.app — each takes under 2 minutes. Or substitute with any other connected plugin (ClickUp, GitHub, Atlassian).
Can't find Cowork? Make sure you're using the Claude desktop app or claude.ai — Cowork plugins are not available in the raw CLI. Run claude from your terminal after connecting plugins in the app.
Step 2 — Create your project folder and launch Claude Open your terminal and start a session in a fresh folder.
macOS — Terminal mkdir ~/connected-workflow
cd ~/connected-workflow
claude

Wait for the prompt. You're inside the session now.

Step 3 — Create a local project brief Write the source file first. All plugin actions will flow from it.

At the prompt, paste this to create a project brief file:

claude prompt Create a file called sprint-brief.md with this content:

Sprint: Week 18 — Onboarding Improvements
Goal: Reduce user drop-off in the first 5 minutes

Tasks:
- Redesign welcome screen copy (Owner: Design, Priority: High)
- Add progress indicator to setup flow (Owner: Frontend, Priority: High)
- Fix tooltip positioning on mobile (Owner: Frontend, Priority: Medium)
- Write onboarding email sequence (Owner: Marketing, Priority: Medium)
- Add skip option to optional setup steps (Owner: Product, Priority: Low)

Success metric: Reduce 5-min drop-off from 60% to 40%

Claude writes sprint-brief.md to your folder. This is the single source — everything else flows from here.

Why write locally first? Local files are fast to edit and don't require an internet connection. Once the content is right, one prompt pushes it everywhere. Edit the markdown, re-push — no reformatting.
Step 4 — Push the brief to Notion One prompt creates a formatted Notion page from your local file.

At the prompt:

claude prompt Using the Notion plugin, read @sprint-brief.md and create
a new Notion page called "Week 18 Sprint Brief".
Format it with a header, goal section, task table
(columns: Task, Owner, Priority), and success metric.
Put it in my main workspace.

Claude calls the Notion API, creates the page, and returns a confirmation with the page URL. Open the URL — your formatted sprint brief is live in Notion right now.

What just happened: Claude read a local file, formatted it as a Notion page, and created it via the plugin — no copy-pasting, no manual formatting in Notion's editor.
Step 5 — Create Linear issues from the tasks Extract the task list and push each one directly into your Linear project.

Run /compact first to keep the session lean, then:

claude command then prompt /compact
claude prompt Using the Linear plugin, read @sprint-brief.md and create
a Linear issue for each task. Set the priority (High/Medium/Low)
and add the Owner as a label. Put all issues in a new cycle
called "Week 18 Onboarding Sprint".

Claude creates 5 Linear issues — one per task — with the correct priorities and labels. Go to Linear and you'll see them all in the new cycle.

Linear API error? Make sure your Linear workspace has at least one project created. Ask Claude: "List my Linear projects and teams so I can tell you where to put the issues."
Step 6 — Save the full workflow to CLAUDE.md The last step: make this workflow reusable with one copy-paste next time.

Ask Claude to save the whole workflow as a reusable prompt in your project memory:

claude prompt Create a CLAUDE.md file for this project. Add a "Workflows"
section that documents the sprint brief workflow we just ran:
create sprint-brief.md → push to Notion → create Linear issues.
Include the exact prompts so I can re-run it next sprint.

Claude writes CLAUDE.md with a documented workflow section. Next sprint: update sprint-brief.md, open Claude, paste the workflow prompts, done. The whole process takes under 5 minutes.

What you built: A repeatable, connected workflow that turns a plain text brief into a Notion page and a full set of Linear issues — automatically, every time. This is the compound value of plugins: you invest 40 minutes once and save hours every sprint.