14 Best Claude Code Plugins in 2026

The best Claude Code plugins in 2026 are Context7 for live version-specific docs, Frontend Design for UI that looks shipped, Superpowers for structured TDD and sub-agent workflows, Chrome DevTools MCP for real-browser debugging, and Anthropic's LSP pack for accurate code intelligence. Round out the stack with the GitHub, Playwright, Semgrep, Linear, and Vercel plugins and you cover repo workflows, E2E tests, security scanning, backlog sync, and deploys.

Claude Code changed the way teams ship software in 2025. By 2026, the question is no longer whether to use it. It is which plugins to bolt on so your agent stops guessing and starts shipping. Anthropic's official marketplace now lists more than 300 plugins (314 entries in its marketplace.json on GitHub when we checked on September 26, 2026), most of them from partners and tool vendors rather than Anthropic itself.

The hard part is separating the plugins that meaningfully change the loop from the ones that just add commands to your terminal. Most plugins do not survive a week of real use. A few become non-negotiable because they reduce hallucinations, anchor Claude to live data, or replace whole categories of manual review. This is the difference between a curiosity install and a plugin that earns a permanent slot in your team's ~/.claude config.

This guide compares the 14 best Claude Code plugins in 2026. Real features, honest pricing where it is publicly known, pros and cons, and a framework to pick the right stack for your codebase.

What are Claude Code plugins and how do you install one?

Claude Code plugins are packages that add skills, agents, hooks, and MCP servers to Claude Code as one unit. To install one, run /plugin in a session and pick it from the Discover tab, or type /plugin install name@claude-plugins-official. Then choose a scope: user, project, or local.

Claude Code adds the official marketplace, claude-plugins-official, the first time you start an interactive terminal session. For a plugin from any other marketplace, add the marketplace first:

/plugin marketplace add owner/repo
/plugin install plugin-name@marketplace-name

From a shell or a setup script, claude plugin install plugin-name@marketplace-name does the same job, and claude plugin list shows what is installed. Anthropic runs three general marketplaces: official (claude-plugins-official), community (claude-community, added with /plugin marketplace add anthropics/claude-plugins-community), and a demo set (claude-code-plugins). Anything else is third-party.

A plugin can run hooks and MCP servers with your user privileges, so read its details pane before you pick a scope. Our guide to Claude Code security risks covers what to check, and if you are starting from zero, how to set up Claude Code comes first. Install steps checked against the Claude Code docs on September 26, 2026.

Best Claude Code plugins: a brief overview

• Context7: Best for up-to-date library documentation injected into prompts.
• Frontend Design: Best for shipping UI that does not look like a 2023 Bootstrap template.
• Superpowers: Best for structured workflows: TDD, brainstorming, sub-agent driven dev.
• Chrome DevTools MCP: Best for live frontend debugging through the real browser.
• Anthropic Language Servers (LSP pack): Best for accurate code navigation and diagnostics across 12 language servers.
• GitHub Plugin: Best for PR review, issue triage, and repo context inside Claude.
• Playwright Plugin: Best for end-to-end test authoring and execution by the agent.
• Semgrep Plugin: Best for explicit static analysis and security scanning steps.
• Linear Plugin: Best for connecting Claude Code to your actual product backlog.
• Vercel Plugin: Best for deploy-aware agents that read logs and ship to prod.
• HOL Plugins: Best for cross-platform plugin discovery with built-in security scanning.
• HOL Guard: Best for pausing risky agent actions before they execute.
• Code Review: Best for a multi-agent first-pass review of pull requests.
• Ralph Loop: Best for letting Claude iterate on a well-specified task until it is done.

1. Context7, best for live documentation

Context7 is the plugin most experienced Claude Code users install first. It is an MCP-backed plugin that pulls version-specific documentation straight from source repositories and injects it into the model's context window. Instead of Claude guessing the current React 19 or Next.js 16 API based on training data, it reads the actual docs at the moment you ask. It is built by Upstash and connects to Context7's hosted remote MCP server.

For teams shipping against fast-moving libraries (Next.js, Tailwind, LangChain, the Vercel AI SDK, Supabase), Context7 cuts an entire class of hallucinations. The tradeoff is latency: every doc lookup adds tokens and a network round-trip.

Key features

• Pulls live documentation from upstream repos and registries
• Version-aware: you can pin which release to read against
• MCP-based, works in Claude Code, Claude Desktop, and Cowork
• Library catalog covers most major JS/TS, Python, Go, and Rust frameworks
• Zero-config: install and reference libraries by name in your prompt

Best for

• Teams working with libraries that change quickly
• Anyone tired of fixing fabricated method signatures
• Projects pinned to specific framework versions

Pricing

• Free

Pros

• Eliminates the most common category of Claude hallucination
• Drop-in, no config files to maintain
• Works alongside any other MCP server

Cons

• Adds token cost to every doc lookup
• Coverage is broad but not exhaustive; niche libraries may not be indexed

2. Frontend Design, best for UI output that looks shipped

Frontend Design is Anthropic's own plugin, listed as Anthropic verified on Claude Marketplace. It exists because raw Claude Code produces functional but generic UI. Frontend Design wires the agent into design tokens, screenshots, layout reasoning, and a curated set of UI patterns so the components it ships actually look intentional.

For agencies and product teams that care about visual polish, this plugin is the difference between Claude generating a wireframe and Claude generating something a designer would not immediately rewrite. It pairs naturally with Chrome DevTools MCP for verifying the rendered output.

Key features

• Design-token aware: respects your existing Tailwind config and CSS variables
• Screenshot-first workflow: Claude sees what it ships
• Built-in component patterns for common UI surfaces
• Works with Shadcn, Radix, and most modern React component libraries
• First-party, maintained by Anthropic

Best for

• Frontend teams that care about visual quality
• Agencies shipping client-facing products
• Solo founders without a designer

Pricing

• Free

Pros

• Anthropic verified on Claude Marketplace
• Backed by Anthropic, not a hobby project
• Composes well with Chrome DevTools and Playwright

Cons

• Adds context overhead even when you only want logic changes
• Cannot replace an actual designer for novel visual systems

3. Superpowers, best for structured workflows

Superpowers reframes Claude Code from a single agent to a small dev team. It ships a curated set of workflows (brainstorming, sub-agent driven development, systematic debugging, red/green TDD, code review) plus tooling to author and test your own skills. It comes from an independent author (obra, github.com/obra/superpowers) and is listed in the official marketplace.

The value of Superpowers is structural. It nudges the agent into patterns that produce better code: write the test first, run the test, fix the failure, review the diff. If your team has tried Claude Code and felt like the agent rushes to a solution, Superpowers is the corrective. For the pick of that stack, see the 10 best Claude Code sub-agents.

Key features

• Sub-agent orchestration with automatic code review handoff
• Built-in TDD loop with red/green/refactor enforcement
• Brainstorming and planning workflows for non-trivial features
• Skill authoring framework: write, test, and ship your own
• Systematic debugging recipes

Best for

• Teams that want consistent agent behavior across engineers
• Anyone moving from "ask Claude to fix a bug" to multi-step delivery
• Skill authors building reusable workflows

Pricing

• Free, open source

Pros

• Battle-tested by a large community
• Forces good habits: test first, review before merge
• Skill framework is genuinely useful for internal tooling

Cons

• Opinionated; fights you if you do not want a TDD loop
• Higher token usage than ad-hoc Claude Code use

4. Chrome DevTools MCP, best for browser-level debugging

Chrome DevTools MCP (chrome-devtools-mcp in the official marketplace, published by the Chrome DevTools team) gives Claude direct access to a running browser via the Chrome DevTools Protocol. The agent can read network requests, inspect console errors, dump the DOM, run scripts in the page context, and screenshot what the user actually sees. For frontend bugs that only reproduce in the browser, this plugin is the difference between Claude guessing and Claude debugging.

It pairs with Frontend Design to close the loop: Frontend Design helps ship UI, Chrome DevTools verifies it works. This is the recommended stack for any team shipping web frontends with Claude Code.

Key features

• Live network inspection (requests, responses, timing)
• Console log and error capture
• DOM querying and manipulation
• In-page JavaScript execution
• Screenshot capture at any viewport size

Best for

• Frontend developers debugging real browser issues
• Anyone working on web performance
• Teams that pair Claude with manual QA

Pricing

• Free

Pros

• Eliminates the "works on my machine" guesswork
• Pairs perfectly with Frontend Design and Playwright
• Zero dependencies beyond a Chromium browser

Cons

• Requires a local browser instance, heavier than pure MCP plugins
• Not useful for non-web codebases

5. Anthropic Language Servers (LSP pack), best for multi-language code intelligence

The official LSP pack bundles 12 language servers into Claude Code: TypeScript, Python, Go, Rust, C/C++, Java, C#, Kotlin, PHP, Ruby, Lua, and Swift. With LSPs active, Claude gets the same code intelligence your IDE has: real types, real symbol resolution, real diagnostics. This is the foundation plugin: install it before anything else if you work in a typed language.

Each language is a separate plugin in the official marketplace (for example typescript-lsp, pyright-lsp, gopls-lsp, rust-analyzer-lsp), so install only the ones for your stack.

Key features

• 12 language servers maintained by Anthropic
• Automatic diagnostics surfaced into Claude's context
• Symbol navigation: "go to definition," find references, rename
• Type-aware refactoring
• Works in any Claude Code project, no config

Best for

• Teams on typed languages (TS, Go, Rust, Java, etc.)
• Large codebases where symbol search matters
• Anyone doing refactors

Pricing

• Free, first-party

Pros

• Single biggest accuracy upgrade for typed-language work
• Maintained by Anthropic, not a community fork
• Zero config

Cons

• Minimal value for untyped or dynamic-only codebases
• LSPs can be memory-heavy on big monorepos

6. GitHub Plugin, best for repo and PR workflows

The GitHub plugin connects Claude Code to your repositories, pull requests, issues, and Actions. The agent can read PR diffs, leave reviews, triage issues, search across repos, and run workflows. For any team using GitHub as the source of truth, which is most teams, this plugin removes the need to copy-paste between terminal and browser.

It is the most common second-install after the LSP pack, and Anthropic actively maintains it as a partner plugin.

Key features

• PR diff reading and review comment posting
• Issue search, creation, and triage
• Cross-repo code search
• GitHub Actions trigger and log inspection
• Branch and commit operations

Best for

• Engineering teams doing structured code review
• Open-source maintainers triaging issues
• Anyone who lives in PRs

Pricing

• Free plugin (your existing GitHub plan applies)

Pros

• Tight integration with the GitHub API surface
• Lets Claude review PRs as a first pass before humans
• Maintained by GitHub as an Anthropic partner

Cons

• Permissions setup requires care; wide tokens are a liability
• Not a replacement for human PR reviewers on critical changes

7. Playwright Plugin, best for end-to-end test authoring

The Playwright plugin lets Claude Code author, run, and debug end-to-end tests against your app. Combined with Chrome DevTools MCP and Frontend Design, it closes the loop on UI changes: Claude builds, screenshots, verifies, then writes a regression test before the diff is committed.

Playwright is also one of the few plugins where the ROI is easy to measure: test coverage written by the agent that would have been deferred or skipped manually.

Key features

• Generates Playwright tests from natural language specs
• Cross-browser support (Chromium, Firefox, WebKit)
• Trace and video capture on failure
• Run tests headless or headed
• Integrates with most CI providers out of the box

Best for

• Teams without dedicated QA engineers
• Apps that ship without enough E2E coverage
• Frontend agencies handing off projects

Pricing

• Free

Pros

• Lowers the cost of writing E2E tests dramatically
• Pairs naturally with Chrome DevTools MCP
• Maintained by Microsoft as a Playwright-native integration

Cons

• Generated tests need human review; flaky selectors happen
• Headless browser overhead in CI

8. Semgrep Plugin, best for explicit security and static analysis

Semgrep gives Claude Code an explicit static analysis step. Where Anthropic's built-in Security Guidance plugin works close to the edit loop, Semgrep is the right pick when your team already uses static analysis rules or wants a more deliberate scan step in the workflow.

For teams shipping in regulated environments (fintech, healthtech, anything touching PII), having Semgrep run before Claude commits is a hard requirement, not a nice-to-have.

Key features

• 2,000+ community-maintained rules across most languages
• Custom rule authoring in YAML
• SAST coverage for OWASP Top 10 patterns
• Integrates with PR-level scanning
• Free OSS tier plus a paid platform for orgs

Best for

• Teams with existing static analysis processes
• Regulated industries
• Security-conscious engineering orgs

Pricing

• Free OSS tier
• Semgrep AppSec Platform: paid (custom contracts for enterprise)

Pros

• Mature rule ecosystem, predates the AI agent era
• Catches things Claude's edit-loop guidance can miss
• Custom rules let you encode org-specific policy

Cons

• Extra step in the loop, slower than implicit guidance
• Free tier rule coverage is good but not exhaustive

9. Linear Plugin, best for backlog and ticket workflows

The Linear plugin connects Claude Code to your product backlog. The agent can read issues, update statuses, create tickets from work it just shipped, and pull acceptance criteria into the prompt context. For product teams using Linear as the source of truth, which is most modern startups, this collapses the gap between "code shipped" and "ticket closed."

This is the plugin that turns Claude Code from a coding assistant into something closer to a delivery teammate.

Key features

• Read, create, and update Linear issues
• Pull issue context into Claude's working memory
• Auto-link commits and PRs to tickets
• Status transitions triggered by code state
• Multi-team and multi-project support

Best for

• Teams using Linear as their backlog of record
• Startups running scrum or shape-up cycles
• Anyone who keeps forgetting to update ticket status

Pricing

• Free plugin (your Linear plan applies)

Pros

• Removes a real source of friction (manual status updates)
• Tight integration via Linear's official API
• Good fit for agency teams managing client backlogs

Cons

• Only useful if your team actually uses Linear
• Auto-close behavior needs guardrails to avoid premature closes

10. Vercel Plugin, best for deploy-aware agents

The Vercel plugin makes Claude Code deploy-aware. It can read build logs, inspect preview deployments, trigger rollbacks, manage environment variables, and pull production runtime logs into the debugging context. For teams shipping on Vercel (Next.js, SvelteKit, Nuxt, any framework Vercel supports), this turns Claude into a deploy engineer instead of just a code author.

It is the single best plugin for shortening the gap between "Claude shipped a change" and "Claude verified the change in production."

Key features

• Read build and runtime logs from any deployment
• Trigger and inspect preview deployments
• Manage environment variables across environments
• Rollback to a previous deployment from chat
• Read Vercel KV, Postgres, and Blob usage

Best for

• Teams hosting on Vercel
• Anyone debugging production-only issues
• Frontend agencies running multiple client deployments

Pricing

• Free plugin (your Vercel plan applies)

Pros

• Closes the loop from code to production
• Official partner plugin, well-maintained
• Excellent pairing with the GitHub plugin

Cons

• Locked to the Vercel platform; not useful for AWS, Cloudflare, or self-hosted teams
• Wide-scope tokens need careful permissioning

11. HOL Plugins, best for cross-platform plugin discovery with built-in security scanning

HOL Plugins is a unified registry for discovering, comparing, and installing extensions across Claude Code, Codex, Cursor, Grok, Kimi Code, DeepSeek Harness, Antigravity CLI, OpenCode, and MCP servers, rather than a Claude Code specific store. Every listed plugin carries a trust score built from publisher identity, activity, and verification signals, plus a security scan for exposed secrets and provenance issues before you ever run an install command.

The catalog itself is honest about the scan's limits: HOL states plainly that its scanning is static, catalog-level scoring, not a live exploit test, so it narrows risk rather than eliminating it. For teams pulling plugins from a marketplace where anyone can publish, that scan plus a visible trust score is still a real step up from installing on faith.

Key features

• Trust score combining publisher identity, activity, and verification, not just star ratings
• Security scanning for exposed secrets and provenance before install
• Single catalog spanning 18 agent ecosystems, filterable across 1,264 tags
• Runtime-specific install commands generated per plugin, per platform

Best for

• Teams running more than one coding agent and tired of checking separate marketplaces
• Anyone who wants a trust signal before installing a plugin from an unfamiliar publisher

Pricing

• Free to browse and use

Pros

• Cross-platform coverage most Claude Code specific directories don't attempt
• Security scanning and publisher verification built into the browsing experience, not an add-on
• Transparent about what the scan does and does not guarantee

Cons

• A trust score is a signal, not a guarantee; HOL says so directly, and it's worth taking at face value
• Newer catalog than Anthropic's own plugin directory, so coverage depth varies by ecosystem

12. HOL Guard, best for pausing risky agent actions before they execute

HOL Guard is a local-first runtime that sits between an AI coding agent and your machine, intercepting risky actions (secret reads, destructive shell commands, unexpected package installs, MCP or plugin configuration changes) and pausing them for approval before they run. It works across Claude Code, Cursor, Codex, OpenCode, Gemini CLI, and others, not just one agent.

The core Guard Local runtime is open source under Apache-2.0 and runs entirely offline; nothing you approve or block leaves your machine unless you opt into Guard Cloud's team dashboards. Anthropic's own agent permissions cover the built-in tool calls Claude Code makes, but they don't watch what a third-party plugin or MCP server does once it's installed. That's the gap HOL Guard is built to close.

Key features

• Pre-execution interception: pauses a risky action for approval instead of letting it run
• Local-first: Guard Local runs and enforces policy entirely on your machine
• Configurable allow, observe, ask, and block outcomes per action type
• Covers file deletion, credential access, data exfiltration, package installs, git operations, and risky MCP/plugin changes
• Activity log of every approved and blocked action

Best for

• Teams that install third-party plugins or MCP servers and want a checkpoint before those extensions touch the filesystem or credentials
• Anyone who wants agent guardrails that work the same way across more than one coding tool

Pricing

• Guard Local (core runtime): free, open source
• Guard Cloud: Solo $4.99/month, Pro $15/month, Team $30/month, Enterprise custom

Pros

• Open-source core, auditable and usable offline with no account required
• Works across multiple agents instead of locking you into one platform's permission model
• Catches actions from third-party plugins and MCP servers, not just the agent's own built-in tools

Cons

• Another approval step in the loop for teams not used to a pause-and-confirm workflow
• Team-wide policy and shared dashboards require the paid Guard Cloud tier

13. Code Review, best for a multi-agent first pass on pull requests

Code Review is an Anthropic plugin (code-review in the official marketplace) that adds a /code-review command. It launches four review agents in parallel: two check the change against your CLAUDE.md guidelines, one scans for obvious bugs, and one reads git blame and history for context. Each issue gets a confidence score from 0 to 100, and only issues at 80 or above are reported. Source: the plugin README in the anthropics/claude-code repository, checked September 26, 2026.

It skips closed, draft, trivial, and already-reviewed pull requests, and it prints to the terminal unless you pass --comment to post the review on the PR.

Key features

• Four parallel review agents per run
• Confidence scoring with an 80 threshold to cut false positives
• CLAUDE.md compliance checks against your own guidelines
• Optional PR comment output with --comment
• Links findings to code with full SHA and line ranges

Best for

• Teams that already keep a CLAUDE.md with real conventions
• Solo developers who want a second reader before merging

Pricing

• No plugin fee appears in the marketplace listing; runs count against your normal Claude Code usage

Pros

• Anthropic-maintained
• Focuses on changes in the PR, not pre-existing issues
• Works from the terminal or as a PR comment

Cons

• Four agents per run use more of your Claude Code allowance than a single review pass
• Issues scored below 80 are filtered out, so it is a first pass and does not replace a human reviewer

14. Ralph Loop, best for iterating on a well-specified task until it is done

Ralph Loop (ralph-loop in the official marketplace, listed with Anthropic as author) implements the Ralph Wiggum technique with a Stop hook. You run /ralph-loop once with a prompt and a completion promise. When Claude tries to exit, the hook blocks it and feeds the same prompt back, so each pass sees the files and git history from the last one. Source: the plugin README in the anthropics/claude-code repository, checked September 26, 2026.

The README stresses clear completion criteria and incremental goals. It works best when tests or a checklist can tell Claude that the job is finished.

Key features

• /ralph-loop "<prompt>" --completion-promise "<text>" starts the loop in your current session
• --max-iterations <n> caps the number of passes
• /cancel-ralph stops an active loop
• Runs inside the session, with no external bash loop

Best for

• Tasks with an objective finish line, such as a passing test suite
• Greenfield work where each pass can build on the last

Pricing

• No plugin fee appears in the marketplace listing; every pass uses Claude Code usage

Pros

• Simple mechanism: one Stop hook, one prompt
• The iteration cap gives you a hard stop

Cons

• The README lists the iteration limit default as unlimited, so always set --max-iterations
• Poor fit for vague or design-heavy tasks with no clear definition of done

How to choose the best Claude Code plugin

1) Should I start with first-party or community plugins?

Start with first-party. The Anthropic-maintained LSP plugins, Frontend Design, Code Review, and Security Guidance are the foundation, and Chrome DevTools MCP comes from the Chrome DevTools team. Once your team has a baseline, layer in plugins from other authors like Superpowers and Context7. Before you install any of them, check for a maintained repo and a clear license. Avoid plugins nobody maintains unless you are willing to fork them. If you want a guided setup, our team builds these stacks for agencies regularly. See Claude Code agency services.

2) What plugin stack should a typical frontend team use?

For a frontend team shipping a Next.js or SvelteKit app: TypeScript LSP (from the Anthropic pack), Frontend Design, Chrome DevTools MCP, Playwright, GitHub, and Vercel. That is six plugins, all free, all first-party or partner-maintained. This stack covers code intelligence, UI quality, browser debugging, E2E testing, repo workflows, and deploy verification. For deeper reading on adjacent setups, see our guide to the best Claude Code skills and the best Claude Code GitHub repos.

3) How many plugins is too many?

Our rule of thumb is 8 to 10 active plugins at most. The Claude Code docs say each enabled plugin's skill, agent, and command names and descriptions sit in context on every turn, even in sessions that never use them. That costs tokens and gives the agent more tools to pick wrong. Open the Installed tab in /plugin and check the Not used recently group, or run claude plugin details <name> to see what a plugin adds to every session. Disable what you do not use with claude plugin disable. Keep your stack tight.

4) What about plugins that are not in the official marketplace?

Many plugins live outside Anthropic's marketplaces, in their authors' own GitHub repositories. You add those with /plugin marketplace add owner/repo, and Anthropic does not review them. Anthropic's community marketplace, claude-community, holds third-party plugins their authors submitted. Some are excellent. Most are abandoned. Rule of thumb: if a plugin does not have a maintained GitHub repo, a clear license, and at least a handful of public users, do not install it. The plugin runs with the same permissions as Claude Code itself, so be careful what you install.

Ship with the right plugin stack

Picking the right plugins is the difference between Claude Code being a clever toy and Claude Code being a deployment-grade teammate. The 14 plugins above are the shortlist we would start from when setting up a stack. AY Automate builds, deploys, and operates Claude Code stacks for agencies and product teams, from initial plugin selection through custom skill authoring and production handoff. If you want a tuned plugin stack for your codebase, start with our Claude Code agency services, browse our companion guides to the best Claude Code GitHub repos and the best Claude Code skills, or book a free consultation and we will audit your current setup.

FAQ

What is a Claude Code plugin? A Claude Code plugin is a directory of skills, agents, hooks, and MCP servers that Claude Code installs as one unit. Plugins are distributed through Anthropic's official and community marketplaces and through third-party marketplaces hosted in GitHub repositories. Once installed, they extend what Claude Code can do without you writing any glue code.

How is a Claude Code plugin different from an MCP server? An MCP server is a single protocol-level integration that exposes tools and resources to Claude. A plugin is a higher-level bundle: it can contain MCP servers, but it can also ship commands, sub-agents, skills, output styles, and hooks. Most plugins wrap one or more MCP servers and add workflow scaffolding on top. If you are picking the underlying servers, start with the 12 best Claude Code MCP servers.

How do I verify a Claude Code plugin is legit? Check three things. First, is it in Anthropic's official marketplace or maintained by a known partner (GitHub, Vercel, Linear, Playwright, Supabase, Sentry, Stripe, Figma)? Second, does the source repo have recent commits and a clear license? Third, what permissions does it request? Wide GitHub or shell access from an unknown publisher is a hard no.

How much do Claude Code plugins cost in 2026? Most plugins are free. The cost usually comes from the underlying service: your GitHub plan, Vercel plan, Linear plan, or Semgrep AppSec contract. The plugins themselves are open source or partner-distributed at no charge. Token usage is the indirect cost: every plugin adds to Claude's context.

How long does it take to set up a Claude Code plugin stack? For a typical 6-plugin stack (LSP pack, Frontend Design, Chrome DevTools, GitHub, Playwright, Vercel), setup is 15 to 30 minutes. Custom skill authoring on top of Superpowers or a tuned MCP server for your internal APIs can take a week or more depending on scope.

Is the official Anthropic marketplace badge important? It is a useful signal, not a guarantee. The official marketplace surfaces vetted, high-quality plugins from Anthropic and major partners. Plugins outside it can still be excellent (Context7 and Superpowers both started as community projects), but you should apply more scrutiny to non-marketplace installs.

Should we use plugins or build our own skills? Both. Plugins solve common problems: docs lookup, browser debugging, deploy logs. Custom skills solve your problems: your internal APIs, your domain logic, your runbooks. Start with plugins for the generic stack, then author skills for anything specific to your codebase. The Superpowers plugin includes a skill authoring framework that is a reasonable starting point.

Can a Claude Code plugin stack train my internal team? Indirectly. A well-chosen plugin stack makes Claude Code consistent across engineers, which standardizes the patterns your team learns. For the fuller picture of team-wide setup beyond just plugins, see our Claude Code for teams guide. If you want a structured rollout (plugins, skills, internal training, and handoff documentation), AY Automate runs this end to end. See our Claude Code agency services or book a consultation. If you would rather build the capability in-house, AI engineer placement embeds a vetted engineer who runs these agent stacks daily.

How do I install a Claude Code plugin? Run /plugin in a Claude Code session, open the Discover tab, and select a plugin, or type /plugin install name@claude-plugins-official. Pick a scope (user, project, or local) and read the install summary. If it says to reload, run /reload-plugins. Then type / and look for the plugin's commands. For a plugin from another marketplace, run /plugin marketplace add owner/repo first.

What is the difference between the official, community, and demo plugin marketplaces? Anthropic publishes three. The official marketplace, claude-plugins-official, is added automatically on first launch and holds plugins from Anthropic and partners. The community marketplace, claude-community, holds third-party plugins their authors submitted, and you add it yourself with /plugin marketplace add anthropics/claude-plugins-community. The demo marketplace, claude-code-plugins, is a small set of examples.

Do Claude Code plugins use tokens when I am not using them? Yes. According to the Claude Code docs, the names and descriptions of an enabled plugin's skills, agents, and commands are in context on every turn, and the full text loads only when used. Run claude plugin details <name> to see the always-on cost, and disable plugins you do not use.

How do I update, disable, or uninstall a Claude Code plugin? Open the Installed tab in /plugin to enable, disable, update, or uninstall a plugin, or use claude plugin disable, claude plugin update name@marketplace, and claude plugin uninstall in your shell. Official marketplaces auto-update by default. Third-party marketplaces do not, so update those by hand.