Best Claude Code Plugins 2026: Superpowers, Context7 and More

The best Claude Code plugins solve a recurring job: PR Review Toolkit for focused review, Superpowers for disciplined implementation, and Context7 for current library documentation. These 9 picks cover review, testing, docs and design handoff, deployment, and project memory. Start with the one that addresses your recurring rework, then add another only when its job is distinct.

Verified on 12 October 2026: the repositories, READMEs, installation documentation, and service pricing linked below were opened for this comparison. The recommendations are based on those sources and workflow analysis, not a signed-in trial or measured time-saving benchmark.

Best Claude Code Plugins at a Glance

PR Review Toolkit is the best first addition for a business codebase with an established development process. It lets you target a specific weakness, such as missing failure-path tests, without adopting a broader implementation methodology. Choose Superpowers first when the recurring problem is how Claude approaches the work.

“No fee listed” means the linked plugin README publishes no separate plugin subscription. It does not mean Claude usage, connected services, or infrastructure are free. Prices below are USD; service tiers are detailed in the relevant sections.

How Plugins and Marketplaces Work

A marketplace is the catalog; a plugin is the bundle you install. The bundle can contain skills, which are reusable task instructions; commands you invoke; specialized agents; hooks that run at lifecycle events; and Model Context Protocol, or MCP, servers that expose external tools. A plugin can contain only one of these types. Installing a documentation connector does not automatically give you a planning framework or a test runner. Claude Code component documentation

The distinction matters when comparing similar names. Context7's package in Anthropic's catalog is a remote MCP connection. Its upstream project also offers a fuller plugin. Read the package you intend to install, rather than combining every capability associated with the brand.

Which Anthropic Plugin Marketplace Should You Add?

For the official-catalog picks below, the source is anthropics/claude-plugins-official and the registered marketplace name is claude-plugins-official. The repository source and registered name are different strings. The current catalog lists these packages and their sources, including external repositories.

External catalog entries can pin a particular source commit. A project's current README and your installed copy can therefore differ. Treat the README as the maker's description, then check the actual installation with claude plugin details before relying on a component. An official catalog entry is still something to inspect, especially when it connects a service or runs local code.

Are the Best Claude Code Skills Different From Plugins?

Skills describe work; plugins package and distribute capabilities. Superpowers supplies a collection of development skills. Playwright Skill combines task instructions with an executable browser-automation helper. Figma adds both workflow guidance and a connection to design data. Choose the smallest package that supplies the missing capability; a larger bundle earns its place only when its additional components serve your workflow.

Code Review: Find Problems Before Merge

Use targeted review when you know the risk; use a pull-request workflow when the review itself needs coordinating. A founder changing a billing integration usually needs scrutiny of retries, errors and tests more than another generic “looks good” response.

1. PR Review Toolkit: Best First Install for Focused Review

PR Review Toolkit is Anthropic's collection of specialized review agents, and the strongest first pick when you already have a working build-and-test process. Its README lists 6 agents: comment-analyzer, pr-test-analyzer, silent-failure-hunter, type-design-analyzer, code-reviewer, and code-simplifier.

What it adds: agents for comment accuracy, behavioral test coverage, error handling, type invariants, general code quality, and simplification. The README describes natural-language requests that select a specialist. Its test agent evaluates whether important behavior is covered; that is different from executing your test suite.

For a subscription-renewal change, ask the test analyst to examine retry behavior and the failure hunter to inspect swallowed exceptions. Name the changed files and the intended behavior. This makes the review address a business failure, such as charging twice or silently losing a renewal, instead of inviting an unrestricted cleanup of unrelated code.

The wall: the agents can identify plausible issues without proving them. Require a reproducible example or a test for a serious finding, and keep your existing automated checks. Run simplification separately after correctness review so a cosmetic refactor does not obscure the original change.

Best for: developers preparing a meaningful change for review.
Standout: selecting the reviewer that matches the risk.
Pricing: MIT-licensed source; no standalone plugin fee listed. Claude usage applies.
Free trial: no time-limited plugin trial listed.
Marketplace: claude-plugins-official.
Install: claude plugin install pr-review-toolkit@claude-plugins-official --scope local.

1. 1

   Pick the failure you care about

   For a renewal change, define the expected behavior when a payment request times out. Give the reviewer the relevant diff and existing tests.

2. 2

   Ask for the matching specialists

   Ask: “Use pr-test-analyzer on the renewal changes, then silent-failure-hunter on the retry and error paths. Report evidence and missing tests; do not edit files.” These names come from the plugin README.

3. 3

   Turn findings into evidence

   For each accepted finding, add or update the relevant regression test in your normal development workflow. Dismiss findings that depend on behavior your application does not have.

Verdict: start here when review quality is the bottleneck and your implementation process already works.

2. Code Review: Best for a GitHub Pull-Request Workflow

Code Review is Anthropic's pull-request review plugin: its command coordinates parallel analysis and confidence filtering, then can publish findings as GitHub comments. The README describes checks against project instructions and repository history, with filtering intended to reduce low-confidence noise.

What it adds: the code-review command, which orchestrates review agents as part of its workflow. This is useful when a small engineering group wants a consistent first pass on an open GitHub pull request before a human reviewer reads it.

For an API pagination change, the useful question is whether the diff violates an existing contract or repository rule. Keep those contracts explicit in project instructions. A confidence score is a prioritization aid, not proof that a finding is correct.

The wall: the documented workflow skips draft, closed, trivial, or already-reviewed pull requests and requires an authenticated GitHub CLI. It can write comments to a shared system. If you want a private review of an unfinished local diff, PR Review Toolkit is the better fit.

Best for: GitHub repositories with an established pull-request workflow.
Standout: coordinating guideline and historical-context review.
Pricing: no standalone plugin fee listed; Claude usage applies.
Free trial: not listed.
Marketplace: claude-plugins-official.
Install: claude plugin install code-review@claude-plugins-official --scope local.

Verdict: choose it for GitHub review coordination; choose PR Review Toolkit for narrower, private analysis.

Testing: Improve the Method and Keep the Evidence

A better implementation process and a browser test solve different problems. Superpowers structures how Claude reaches a change. Playwright Skill helps create an executable artifact that demonstrates what the browser did.

3. Superpowers Plugin: Best for Test-First Development

Superpowers is Jesse Vincent and Prime Radiant's development-methodology plugin, built around skills for defining work, planning it, implementing it and checking the result. Its README describes automatic skill selection, test-driven development, systematic debugging, worktrees and review workflows.

What it adds: development skills, including brainstorming, writing-plans, test-driven-development, systematic-debugging, and verification-before-completion. Its source also contains a SessionStart hook that loads the bootstrap instructions. This is a workflow package, not a new model or an independent test service.

Test-driven development means writing a test that fails for the missing behavior before implementing the fix. For a duplicate-webhook bug, the useful sequence is a reproducible duplicate delivery, a failing assertion about the resulting state, and a fix that makes the assertion pass. Superpowers' value is making that sequence part of the work instead of an optional final request.

The wall: process has a cost. A naming correction should not become a design workshop, and a mature team should not silently replace its own workflow with a plugin's preferred method. Adopt it for bounded feature work or difficult debugging first. Judge the resulting evidence and diff, rather than how elaborate the plan sounds.

Best for: developers whose coding agent starts implementing before the task is clear.
Standout: an explicit path from design through verification.
Pricing: MIT-licensed source; Claude usage applies. Commercial support is offered without a public amount in the README.
Free trial: no timed plugin trial listed.
Marketplace: claude-plugins-official; the maker also maintains superpowers-marketplace.
Install: claude plugin install superpowers@claude-plugins-official --scope local.

Verdict: install it when premature implementation causes rework; keep the scope of each task explicit.

4. Playwright Skill: Best for Reusable Browser Tests

Playwright Skill, from lackeyjb/playwright-skill, is a browser-automation skill packaged as a Claude Code plugin. Its README describes a code-first approach: Claude writes a Playwright program, and the included executor runs it.

What it adds: the playwright-skill skill, a run.js executor and supporting helpers. It supports browser programs with assertions, loops, multiple contexts, network interception and screenshots. This is a specific community plugin, distinct from Microsoft's Playwright MCP server.

For a public signup form, ask for a script that checks empty submissions, invalid input and the success state against a local development fixture. The payoff is the script you can inspect, keep and rerun. A screenshot alone cannot establish that the correct request was sent or that an error state behaved correctly.

The wall: generated automation can be brittle. Review selectors, assertions, fixture data and cleanup before treating the script as a regression test. The package requires Node.js and setup that installs Playwright and Chromium; a visible browser is the documented default.

Best for: web developers who need repeatable evidence for browser behavior.
Standout: producing an automation program instead of only an interaction transcript.
Pricing: MIT-licensed source; no plugin fee listed. Claude usage applies.
Free trial: no timed plugin trial listed.
Marketplace: playwright-skill, from lackeyjb/playwright-skill.
Install: claude plugin install playwright-skill --marketplace lackeyjb/playwright-skill --scope local.

After reviewing its scripts, follow the README's setup in the installed skill directory: npm run setup. Its documented marketplace location is ~/.claude/plugins/marketplaces/playwright-skill/skills/playwright-skill; confirm your actual installed path before using it.

Verdict: choose it when the automation itself should become a maintained artifact.

Docs and Design Handoff: Bring the Source Into the Task

Use the source that answers the actual uncertainty. Library documentation resolves an API question. A Figma component resolves a design question. Giving Claude more unrelated context makes neither answer better.

5. Context7: Best for Current Library Documentation

Context7, maintained by Upstash, retrieves library documentation and examples through MCP. The official-marketplace package README describes a hosted remote connection, so this particular package requires no local Node.js, npm or npx process.

What it adds: the MCP tools resolve-library-id and query-docs. The first identifies the library and available versions; the second retrieves relevant documentation. The README points to a fuller upstream plugin with additional components, but those should not be assumed to exist in this thin connector package.

For a framework upgrade, give Claude the version installed in your repository and ask it to resolve the matching documentation before changing an API call. Review the returned library identity. A correct answer for a different version is still a regression risk.

The wall: coverage and available versions determine what can be retrieved. Anonymous access shares anonymous limits, while an API key uses your plan. Do not assume an anonymous connection has a personal Free-plan allowance.

Best for: teams working with libraries whose APIs change frequently.
Standout: explicit library and version selection before retrieving examples.
Pricing: Free $0 with 1,000 calls/month; Pro $10/seat/month with 2,000 calls per seat, then $5 per 1,000 additional calls. Private-repository parsing costs $5 per 1M tokens.
Free trial: a Free plan is available; no time-limited Pro trial is listed.
Marketplace: claude-plugins-official.
Install: claude plugin install context7@claude-plugins-official --scope local.

The plans page, checked on 12 October 2026, lists Enterprise as custom. Its FAQ says small teamspaces start at $30/user/month and large organizations can go as low as $2.50/user/month. Enterprise includes 2,000 calls per seat, with additional calls and private parsing charged at the rates above; ask for the applicable quote rather than treating the lowest rate as universally available.

Verdict: a strong addition when outdated API assumptions repeatedly cause fixes and rework.

6. Figma: Best for Design-to-Code Handoff

Figma's plugin connects Claude Code to design context and adds workflow skills for using it. The maker's repository README recommends the plugin for Claude Code and describes retrieving components, variables and layout information from selected design nodes.

What it adds: Figma MCP configuration plus skills for implementing designs, connecting components through Code Connect, and creating design-system rules. Code Connect associates design components with the corresponding code components. The remote server also supports canvas changes, so this connection should not be treated as inherently read-only.

For an onboarding screen, provide the exact frame link and name the existing components Claude should reuse. Retrieve structured design context and a screenshot, then compare the implementation against both. The README specifically warns that generated structure needs translating into your application's framework and conventions.

The wall: an untidy design file still produces an ambiguous handoff. Unnamed layers, missing variables and unmapped components leave decisions for the model to guess. Account access and MCP allowances also depend on the plan and seat; a cheap collaboration seat is not automatically the right development seat.

Best for: a developer implementing a defined Figma design in an existing application.
Standout: combining visual reference with component and variable context.
Pricing: no separate plugin subscription stated. Figma Starter is free; paid seat prices below.
Free trial: no standalone plugin trial stated.
Marketplace: claude-plugins-official, sourced from figma/mcp-server-guide.
Install: claude plugin install figma@claude-plugins-official --scope local.

The following are monthly equivalents under annual billing, as displayed on Figma's live pricing page on 12 October 2026. They are service-seat costs, not plugin charges.

Verdict: install it when Figma is the source of design decisions; do not add it merely to make an unspecified interface look better.

Deployment: Connect Only the Infrastructure You Use

A deployment plugin earns its place when it understands the platform you already operate. Its convenience also puts account-level operations closer to the coding conversation, which makes the target project and environment worth stating explicitly.

7. Vercel: Best for Vercel Deployment Operations

Vercel's vercel-plugin repository provides a broader operations package than a deployment shortcut. Its README describes ecosystem guidance, skills, specialized agents, commands, lifecycle hooks and a bundled connection to Vercel's remote MCP server.

What it adds: deployment, environment, status and bootstrap commands; agents including deployment-expert, performance-optimizer and ai-architect; and platform skills. The README also describes session-start context for relevant projects. It no longer presents automatic skill injection on every prompt or tool call as the default.

For a failed preview build, identify the intended Vercel project and ask for the build failure and relevant environment mismatch before requesting any change. This keeps investigation separate from deployment. The MCP connection can inspect projects and logs, create deployments and update resources, subject to the account access you grant.

The wall: this is platform-specific tooling with read and write capabilities. A request to diagnose a preview should not imply permission to alter production. The package also has local prerequisites and telemetry settings: its README lists Node.js 18+ and Bun, and documents VERCEL_PLUGIN_TELEMETRY=off for opting out.

Best for: developers already shipping applications on Vercel.
Standout: deployment knowledge and account tools in one package.
Pricing: no separate plugin fee stated. Vercel Hobby is $0/month for personal, non-commercial use; Pro starts at $20/month plus usage; Enterprise is custom.
Free trial: the platform offers a Pro trial; no duration is assumed here.
Marketplace: claude-plugins-official, sourced from vercel/vercel-plugin.
Install: claude plugin install vercel@claude-plugins-official --scope local.

Vercel's pricing page, verified on 12 October 2026, lists developer seats at $20/month and a $20 included usage credit for Pro. A business should budget for its seats and usage, rather than assuming the personal Hobby plan is the commercial starting point. The README uses more than one command prefix across installation paths; use your installed command picker to select the actual deploy or status command.

Verdict: a good operational fit for a Vercel business application, provided every action names its environment.

Project Memory: Save Rules Before Saving Everything

Curated instructions and captured history are different kinds of memory. Start with durable rules that describe how the repository works. Add historical recall when repeatedly reconstructing previous investigations has become a separate problem.

8. CLAUDE.md Management: Best for Keeping Project Instructions Current

CLAUDE.md Management is Anthropic's small maintenance plugin for the instruction files Claude reads in a project. Its README separates auditing those files from capturing what the current session taught you.

What it adds: the claude-md-improver skill checks project instructions against the codebase, while the revise-claude-md command captures session learnings. It is a focused choice for a repository whose test command, architecture notes or working conventions have drifted.

Suppose a service now uses a different local test setup. Update the durable instruction that will matter next week, then review the diff as documentation. Do not save the entire troubleshooting conversation when the useful result is a short command and an explanation of when it applies.

The wall: instructions can become cluttered or contradictory. Treat suggested additions as candidates for review. Preserve stable rules and remove superseded ones; memory is useful when it reduces the next session's uncertainty, not when it records everything.

Best for: business repositories with stale or incomplete project guidance.
Standout: separating periodic instruction audits from session-learning capture.
Pricing: no standalone plugin fee listed; Claude usage applies.
Free trial: not listed.
Marketplace: claude-plugins-official.
Install: claude plugin install claude-md-management@claude-plugins-official --scope local.

Verdict: the better first memory plugin when the problem is repeated setup and convention mistakes.

9. Claude-Mem: Best for Searchable Cross-Session History

Claude-Mem, maintained in thedotmack/claude-mem, captures tool-use observations, summarizes them and makes them available to later sessions. Its README describes a persistent memory system with more moving parts than a project instruction file.

What it adds: lifecycle hooks, a local worker, SQLite storage, a mem-search skill, and MCP retrieval tools including search, timeline and get_observations. The documented retrieval pattern narrows an index before fetching the details of relevant observations.

For a recurring background-job failure, useful recall might be the previous root cause, the rejected fix and the files involved. That history can help frame the next investigation. Still check whether the current code and configuration match the remembered situation before following an old conclusion.

The wall: capture creates another data store and another process to manage. Review which content is stored, which model processes it, whether cloud sync is enabled, and what context is injected. The README documents privacy tags, but those are not a reason to put credentials into the conversation. It lists Node.js 20+ and automatic installation of Bun and uv when missing.

Best for: developers whose recurring cost is reconstructing past investigations.
Standout: searchable observations and chronological context across sessions.
Pricing: the local open-source engine is free; model/provider usage may cost separately. Hosted CMEM Pro is $30/month, Heavy $70/month, and CMEM Max $100/month plus overages.
Free trial: the hosted service advertises 30 days, subject to its usage and billing conditions below.
Marketplace: thedotmack, from thedotmack/claude-mem.
Install: claude plugin install claude-mem --marketplace thedotmack/claude-mem --scope local.

The live pricing page, checked on 12 October 2026, says hosted-trial billing can begin when the trial ends or its included usage is exhausted, and a card is required. Included allowances and automatic-upgrade terms are shown in the purchase flow. TeamBrain is a pilot with individually agreed pricing, not a public fixed-price team tier. The local engine remains a separate option.

Verdict: add it after identifying a historical-recall problem that a concise CLAUDE.md cannot solve.

Install and Manage Plugins Without Losing Track

Review the source first, then install at the scope you intend. The commands in this section describe the current public workflow; they were checked against the documentation, not executed against a signed-in account.

The conventional shell path is to register the source with claude plugin marketplace add anthropics/claude-plugins-official, then install a qualified name such as claude plugin install pr-review-toolkit@claude-plugins-official --scope local. Registering a catalog does not mean you should enable every package in it.

The New --marketplace Shell Flag

Claude Code v2.1.292, released on 6 October 2026, added --marketplace to the shell's claude plugin install. It combines adding a marketplace, if needed, with installing the selected plugin. Official release notes

For example: claude plugin install superpowers --marketplace anthropics/claude-plugins-official --scope local.

Use the plugin name without an @marketplace suffix in this form. The shell adds the marketplace without a separate confirmation step, subject to organization policy. The marketplace declaration goes into user settings even if the plugin is installed at project scope. Inside an interactive session, /plugin install ... --marketplace ... is a separate workflow that opens plugin details; it has been supported since v2.1.275. Current installation documentation

Choose Scope Deliberately

Use local scope for a repository-specific personal choice. User scope is the default and applies across your projects on that machine. Project scope records the shared choice in the repository. The settings locations are:

• User: ~/.claude/settings.json.
• Project: .claude/settings.json.
• Local: .claude/settings.local.json.

Local settings take precedence over project settings, which take precedence over user settings. A committed project entry enables the plugin for collaborators, but it does not download the package to their machines; each collaborator still installs it. Scope documentation

Keep an Inventory and an Exit Path

Use claude plugin list for versions, scopes and status, and claude plugin details pr-review-toolkit@claude-plugins-official for the installed components. The details output also helps identify the plugin's always-on context cost.

For a local install, the matching lifecycle commands are claude plugin update pr-review-toolkit@claude-plugins-official --scope local, claude plugin disable pr-review-toolkit@claude-plugins-official --scope local, and claude plugin uninstall pr-review-toolkit@claude-plugins-official --scope local. Use enable to re-enable a disabled copy. Load changes with /reload-plugins in the session or start a new session. Plugin command reference

The official marketplace has auto-update enabled by default; third-party marketplaces default to off. Check the Marketplaces tab in /plugin and choose the policy you intend. Review updated source before a broader rollout, because the code you inspected previously may have changed.

Review a Plugin Before Enabling It

Treat a plugin as code running under your account, not as a harmless prompt download. Anthropic's security documentation states that plugins can execute arbitrary code with your user privileges. Hooks, monitors and server processes run outside the sandbox used for Claude's tool calls. Permission rules on those tool calls do not make the plugin's own processes sandboxed.

That distinction matters even for a plugin installed at local scope. Local scope limits where it is enabled; it does not isolate the process from your files or credentials.

1. 1

   Trace the catalog to the source

   Run claude plugin marketplace list to see registered sources. In /plugin, read the component summary and open the repository. Confirm the publisher, plugin directory and source revision. If the summary is unavailable, inspect the source rather than treating missing information as an empty component list.

2. 2

   Read what can execute or send data

   Inspect hooks/hooks.json, .mcp.json, bin/, dependency-install scripts and the files those entries invoke. For a local server, inspect its executable command. For a remote server, inspect its destination and requested access. Read skills, commands and agents too: their instructions influence what Claude does with its existing tools.

3. 3

   Validate the exact plugin directory

   For a reviewed local checkout, run claude plugin validate ./plugin-directory --strict. Add --json when collecting the result in automation. The validator checks supported structure and content rules; it does not establish that the code is trustworthy. Validating a marketplace alone does not inspect the component files of every plugin listed in other directories. Validation reference

4. 4

   Inspect the inventory before a session

   Use claude --plugin-dir ./plugin-directory plugin details plugin-name, replacing the directory and name with the reviewed package. The documented command reads its inventory without starting a session. Installation normally enables a plugin, so review its source before installing. Afterward, compare the installed details with the inventory you expected. Source-review documentation

For automated validation, exit code 0 means a pass, 1 means validation failed, and 2 means an unexpected validator error. With --strict, warnings also fail. None of those outcomes is a security certification. For behavior checks beyond package validation, use the site's guide to Claude Code plugin evals.

For a business rollout, record the chosen source revision, permitted service accounts, expected components and owner of updates. A plugin that deploys infrastructure deserves a different review from a skill that supplies formatting guidance. Keep production authority explicit in either case.

Who Should Pick What

Pick by the work you repeatedly redo. If developers miss failure paths, start with PR Review Toolkit. If Claude rushes into implementation, choose Superpowers. Add Playwright Skill when you need browser behavior captured in reusable scripts.

Choose Context7 when version-specific API mistakes recur. Add Figma when design decisions already live in Figma files. Add Vercel when that is where your application runs and account operations are part of the job.

For memory, choose CLAUDE.md Management when the missing information is a durable project rule. Choose Claude-Mem when it is an older investigation you need to search. The decision flips on curated instructions versus historical recall, not on which package advertises more memory.

On Monday, take one recently painful change and identify the missing capability. Review and install the matching plugin, define the artifact you expect from it, and retain it only if it improves that task without adding another recurring maintenance problem. Do not install all nine as a starter pack.

When the useful workflow is specific to your company, the next step may be your own small package. See how to publish Claude plugins. If your developers also use Codex, use the separate Codex plugin and team-marketplace guide for that environment.

How These Were Picked

Every recommended plugin has an accessible repository and a README that explains what it adds. Selection favored a recognizable job on a business codebase, a traceable install source, a concrete component inventory, and a limitation that helps decide when to skip it.

The verification on 12 October 2026 compared maker READMEs with the official catalog, current Claude Code documentation and relevant live pricing pages. Where sources disagreed, disputed counts were omitted and live pricing took precedence for billing terms. No rankings depend on install totals, stars, ratings or claimed speedups.

This is a documented comparison, not a runtime compatibility guarantee or a security audit of every line. The practical recommendation is intentionally conditional: use the package whose job matches your bottleneck, then review the particular revision you enable.

The Ones to Avoid

Avoid redundant or mismatched installations before looking for more plugins. These are specific cases where an otherwise useful package becomes a poor choice:

• Code Review for a draft-only workflow: its README says draft pull requests are skipped. Use a targeted review request instead of wondering why the PR workflow did nothing.
• Superpowers from multiple marketplaces at once: choose one source for the same methodology. Multiple update origins make the installed behavior harder to track.
• Claude-Mem installed only with npm install -g claude-mem: the maker says this installs the SDK/library, not the plugin hooks and worker setup. Use the documented plugin installation route.
• Both review packages on every trivial edit: overlapping review consumes attention without establishing that either found an additional defect. Give each a distinct job if you retain both.
• An unreadable-source bundle: skip a package whose repository, component files or invoked installer cannot be inspected. A marketplace label or a long feature list is not a substitute for the source.

Questions From a Daily Claude Code Workflow

How do I use Claude Code Superpowers on an existing codebase?

Install it from one reviewed marketplace at the scope you intend, then begin with a bounded feature or bug. State the existing test command and project constraints, ask for the design or plan before implementation, and judge the resulting tests and diff. Its documented skills supply the process; your repository still supplies the acceptance criteria.

Does claude plugin validate prove a plugin is safe?

No. It checks supported manifests and component rules. Read the executable hooks, server commands, dependencies and instructions separately. Validate the actual plugin directory, because a marketplace-level pass does not inspect every listed plugin's component files.

Will a project-scope install set up every developer automatically?

No. The shared setting enables the plugin for the repository, but collaborators still need to install it on their machines. Record the marketplace source and install command with the project setup instructions.

Should I install both memory plugins?

Only if they solve different problems. CLAUDE.md Management maintains curated project instructions; Claude-Mem captures searchable history. Start with the missing kind of memory and decide what should be retained before enabling broader capture.

For more practical ways to audit and improve a business workflow, join the newsletter.