How Many Claude Code Plugins Should You Install? (The 4-6 Rule)

Mar 11, 2026

I opened my Claude Code settings one day and found 23 plugins enabled. I couldn’t remember what half of them did. My context window was bleeding tokens before I typed a single line of code.

Here’s the answer I wish I had: install 4-6 plugins maximum. Start with zero and add only what solves specific workflow pain points.

The Problem: Every Plugin Costs Context

Claude Code operates within a finite context window. Every plugin you install adds to the system prompt—the invisible instructions that tell Claude how to behave.

Each plugin can contain multiple components:

Commands     -> Slash commands added to system prompt
Agents       -> Subagent definitions loaded on startup
Skills       -> Auto-activating knowledge bases
Hooks        -> Event handlers running on triggers
MCP Servers  -> External system connections

All of this loads before you write a single line of code.

With 30 plugins, your system prompt could consume 10,000-20,000 tokens. For complex tasks requiring multi-file reasoning, this overhead becomes critical.

Community Consensus: 4-6 Maximum

A recent r/ClaudeCode discussion (51 upvotes, 52 comments) revealed experienced users settling on the same number:

Top comment (86 votes):
"If you can't explain what each plugin does for your specific
workflow without looking it up, delete it. 30 plugins means
a massive system prompt which means less context for your
actual code."

Experienced user recommendation: 4-6 plugins maximum
Minimalist view: "Ideal plugin count is zero" (7 votes)

The model is smart enough on its own. Plugins should fix specific pain points, not be collected like trading cards.

Real Production Example: 2 Plugins

My production setup uses only 2 plugins despite having 50+ skills available locally:

{
  "enabledPlugins": {
    "playwright-skill@playwright-skill": true,
    "memsearch@memsearch-plugins": true
  }
}

This is deliberate. I chose to minimize plugin overhead because every token spent on system prompt is a token unavailable for reasoning about my code.

The Plugin Evaluation Framework

Before installing any plugin, I ask four questions:

1. Does this solve a problem I actually have?
2. Can I name this plugin's purpose right now?
3. Will I use this at least once per week?
4. Does Claude lack this capability natively?

If I can’t answer “yes” to all four, I don’t install.

When to Install vs. When to Skip

GOOD REASONS TO INSTALL          | BAD REASONS TO INSTALL
--------------------------------|--------------------------------
E2E testing automation          | "It looks useful"
Memory/persistence across       | Collecting features like
  sessions                        trading cards
Language-specific tooling not   | FOMO from seeing others'
  in Claude's core                setups
Browser automation              | Replacing Claude's built-in
                                  capabilities

Skills vs. Plugins: Know the Difference

Skills and plugins serve different purposes:

SKILLS                          | PLUGINS
--------------------------------|--------------------------------
Project-specific                | Global across all projects
Live in .claude/skills/         | Live in ~/.claude/plugins/
Load only when relevant         | Load on every session
Context-aware                   | Always loaded
Unlimited count                 | Limit to 4-6

Recommendation: Use skills for project-specific workflows (unlimited, context-aware loading). Use plugins for universal tooling (limit to 4-6).

How to Audit Your Current Setup

Check your enabled plugins:

# Check your enabled plugins
cat ~/.claude/settings.json | grep -A 20 "enabledPlugins"

For each plugin, ask: “Have I used this in the last 30 days?” If no, remove it.

Replace Plugins with Skills

Instead of installing a plugin, create a project-level skill:

---
name: api-testing
description: Use when writing API integration tests
version: 1.0.0
---

# API Testing Guidelines

When writing API tests:
1. Use descriptive test names that document behavior
2. Test happy path and error cases
3. Validate response structure and status codes
4. Mock external dependencies

This skill loads only when I’m writing tests, saving context for other tasks.

Red Flags: When You Have Too Many

Your plugin count is excessive if:

You can’t name each plugin’s purpose without checking
Claude’s responses feel slower or less accurate
Complex tasks fail or produce inconsistent results
You’ve never used some installed plugins
Your enabledPlugins has more than 10 entries

The Math That Matters

From performance optimization guidelines:

“Avoid last 20% of context window for:

Large-scale refactoring

Feature implementation spanning multiple files

Debugging complex interactions”

Every plugin pushes you closer to that critical 20% threshold where complex tasks become unreliable.

Total Context Window:     200,000 tokens
Available for your code:  160,000 tokens (80%)
Reserved threshold:        40,000 tokens (20%)
Plugin overhead:           ? tokens (depends on count)

The more plugins, the less room for your actual work.

Final Recommendation

Keep your enabled plugin count between 0-6, with most users optimal at 2-4. The principle is simple: minimal sufficiency. Install the fewest plugins necessary to solve your actual workflow problems.

The model is already powerful. Plugins should complement, not replace, Claude’s built-in intelligence. If you can’t explain what a plugin does for your workflow without looking it up, delete it.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 What skills are you using? - r/ClaudeCode Discussion

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!