10 Best Claude Code Plugins in 2026

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. The plugin marketplace went from a handful of experiments at the end of 2024 to over 9,000 third-party entries by mid-2026, with Anthropic itself curating roughly 100 first-party and partner plugins in the official directory.

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: 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 10 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.

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+ languages.
• 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.

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. As of June 2026, Anthropic's public directory reports roughly 348,000 installs.

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
• No usage caps published as of mid-2026

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 and the most-installed plugin in the official directory at roughly 829,000 installs by June 2026. 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

• Highest install count in the official marketplace for a reason
• 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. With 752,000+ installs, it is one of the most popular community plugins in the 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.

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 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 — TypeScript, Python, Go, Rust, C/C++, Java, C#, Kotlin, PHP, Lua, Swift — into Claude Code. 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.

The Composio team and most of the early adopters in the Anthropic dev community recommend starting any Claude Code setup with the LSP plugins for your stack. The improvement in agent accuracy on typed codebases is immediate and obvious.

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

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 pack, Frontend Design, Security Guidance, and Chrome DevTools MCP are the foundation. They are stable, documented, and not going to disappear. Once your team has a baseline, layer in high-traction community plugins like Superpowers and Context7 — both have hundreds of thousands of installs and active maintainers. Avoid plugins with fewer than a few thousand installs 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?

Anything past 8-10 active plugins starts hurting more than it helps. Every plugin adds tools to Claude's context, which means more tokens spent on tool descriptions and more chance the agent picks the wrong tool. Audit your ~/.claude/plugins.json quarterly. If a plugin has not been invoked in 30 days, disable it. Keep your stack tight.

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

Most of the 9,000+ community plugins live outside the official directory in places like ClaudePluginHub and claude-plugins.dev. 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 — 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 10 plugins above are the ones we install for clients before we even start writing code together. 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 packaged extension that adds new commands, sub-agents, MCP servers, skills, or workflows to Claude Code. Plugins are distributed via Anthropic's official marketplace, partner marketplaces, and community directories like ClaudePluginHub. 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.

How do I verify a Claude Code plugin is legit? Check three things. First, is it in the Anthropic-managed 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 six-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. 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.