Claude Code Is Slowing Down: How to Choose Skills, Subagents, MCP, and Plugins

Why Has “Stuffing Claude Code” Become the Biggest Pain Point in 2026?#

Even the official documentation had no ready-made comprehensive answer to “when should you choose what?”

The month-long experience described in this article includes all four mechanisms in working projects: a stack of subagents for one complex task, a small set of skills for recurring procedures, a couple of MCP servers for live data, and a selection of a few from roughly two dozen plugins. This guide brings the example together in a selection matrix with a ready-made decision tree, Anthropic quotes, and seven anti-patterns that make Claude unusable.

How Does a Skill Differ from a Subagent, MCP, and Plugin in One Table?#

Selection matrix:

A simple analogy for an entrepreneur: imagine yourself as the CEO of a ten-person company:

• CLAUDE.md — the company charter. Always on the wall; everyone reads it; no one argues.
• Skill — an internal procedure. “How we do reviews,” “how we write release notes,” “how we accept payment.”
• Subagent — a specialist with a separate office and a narrow list of permissions. Give them the keys to everything and you’ll get a second CEO, not an employee.
• MCP server — corporate systems: CRM, bank, warehouse. This is not knowledge; it’s a connection.
• Plugin — an off-the-shelf solution from a store. A package of procedures, specialists, and integrations in one box.

Once you understand these are four layers of one system rather than four competitors, the question “which is better?” goes away. The question that remains is “what goes where?”

What Is a Skill in Claude Code, and When Should You Install One?#

Anthropic’s official definition:

A skill has three levels:

1. Metadata. Always loaded at session startup: the name and description from the frontmatter. One skill uses about 100 tokens at startup.
2. Instructions. Loaded only when Claude sees a triggering request. Up to 5,000 tokens—the body of SKILL.md.
3. Resources. Loaded only when the instructions explicitly call for them. Bundle files, scripts in scripts/, reference materials in references/. Scripts run through bash; the code itself does not enter the context.

Anthropic calls this principle progressive disclosure:

And in the same article, a metaphor that explains the idea better than anything else:

When to use a skill:

• A standard procedure you repeat again and again. PR reviews, release notes, code review according to your style guide.
• When a section in CLAUDE.md has grown from a fact into a procedure and starts getting in the way of everything else.
• When you want the same instruction to be followed consistently across different projects.

A practical formula: if you do something more than a couple of times, hand it over to the system. The first time, use a manual prompt. The second time, it’s a candidate for a skill.

When NOT to use a skill:

• If the task requires live data (database, API, search, current stock exchange data). That’s MCP, not a skill. A skill that tries to “fetch the current price” will hallucinate.
• If the task requires isolated context. That’s a subagent.
• If you need an enforced check (“block a commit containing .env”), use a hook for the covered commit path rather than relying on a skill. Review and test its actual coverage; a hook does not restrict every way of reading, copying, or publishing the file.

Limits to know in advance:

• Skill name: up to 64 characters, lowercase letters, digits, and hyphens only. The words anthropic and claude are reserved.
• Description: up to 1,024 characters. The combined description + when_to_use is truncated at 1,536 characters in the list.
• SKILL.md body: the recommendation is no more than 500 lines. Move anything beyond that to references/ and scripts/.
• During automatic context compaction (auto-compaction), each active skill gets the first 5,000 tokens reattached. The total budget for all skills is 25,000.

What Is a Subagent, and Why Are There 5 Levels of Nesting?#

From the official documentation:

Claude Code has three built-in subagents you already use without knowing it:

On June 10, 2026, Anthropic released Claude Code v2.1.172 and removed a restriction that had been in place since subagents launched: child agents can now spawn their own subagents up to 5 levels deep.

The number 5 is a safety ceiling, not an optimization target.

A detailed feature breakdown with YAML orchestrator templates is in the guide to nested subagents.

When to use a subagent:

• An exploratory pass through code or logs after which you need only a short conclusion.
• Parallel tasks that can run side by side.
• Delegation by specialization: backend / frontend / test / review—each handling one feature.
• Cost control: a Haiku subagent instead of Sonnet or Opus. This reduces the bill by 5–7 times.

When NOT to use a subagent:

• A one-off trivial task or a simple tool call. A subagent has startup cost.
• When tasks need to share state. Subagents can’t see each other’s context; related work should stay in the main thread.

The main anti-pattern: a subagent with the same permissions as its parent is just a second CEO. Pointless and expensive.

What Is an MCP Server, and When Should You Connect One to Claude Code?#

The official definition:

What MCP actually lets you do in practice:

• Connect Claude to Google Calendar and Notion to get a personal assistant.
• Connect to Figma so Claude generates a ready-made web project from a design.
• Connect a corporate chatbot to several databases at once.
• Connect to Blender and a 3D printer to create models and print them immediately.

The best-known MCP servers people install first:

Connections and installation commands are collected in the MCP catalog.

When to use MCP:

• Any connection to external data or actions: “fetch rows from the database,” “read Jira tickets,” “post in Slack.”
• When the same service is needed by several projects or agents, it’s easier to keep one centralized server.

When NOT to use MCP:

• Static knowledge or a procedure. That’s a skill, not MCP. “Instructions for how to do code review” is a skill. “Read the latest PR from GitHub and review it” is MCP.
• A one-off CLI command. It’s easier to use Bash than to set up a server.
• When you want to build MCP “for the sake of proper architecture.” That’s aesthetics, not a task.

The main MCP trap is one of the biggest sources of complaints that “Claude Code is acting dumb” in 2026: when you install many MCP servers at once, all their tools are loaded into the context.

A practical rule of thumb: keep no more than 2–3 active MCP servers aimed at specific tasks. In the described experience with many servers, startup was slower and errors occurred more often.

MCP tool search was added in Claude Code v2.1.x: tools are no longer loaded greedily into the context, but indexed and fetched on demand. This reduces the cost of “many MCPs in a project,” but doesn’t eliminate it completely.

How Does a Plugin Differ from a Skill, and Why Has the Boundary Blurred?#

The official wording:

Leaders by installs in June 2026:

The full selection analysis is in the guide to the top 10 plugins out of 101.

When to use a plugin:

• A ready-made community bundle that covers a large part of a workflow, such as design or review.
• When you don’t want to assemble a “skill + subagent + MCP + hook” setup by hand, you can use a ready-made one.
• Corporate distribution: an administrator creates a team marketplace, and developers install from a single prefix.

When NOT to use a plugin:

• The task can be solved with one skill, but the bundle brings along five more MCPs “just in case.” That’s pure context clutter.
• A closed-source plugin with no audit. It runs with your permissions—read its contents before installation.
• You already have your own plugin on the same subject. A duplicate in the context means double the pain.

Before installation, Claude Code v2.1.143+ shows Context cost, an estimate of tokens the plugin will add to each message. Since v2.1.145+, it shows the Will install field with a complete list of the bundle’s commands, agents, skills, hooks, MCP, and LSP. Before clicking install, that’s the first screen to open.

Which Selection Matrix Works in 2026?#

Six questions, in order of priority:

1. Is this a recurring procedure, style, or checklist? If yes—skill.
2. Do you need external data or actions (database, API, Slack, GitHub, Figma)? If yes—MCP server.
3. Do I want a separate context so I don’t clutter the main one? If yes—subagent.
4. Do I want a check or automatic step at a defined event? If yes—hook, with its coverage tested; use permissions or environment isolation for broader access boundaries.
5. Do I want a ready-made bundle of 1–4 in one click? If yes—plugin from the marketplace.
6. Is this a complex task that needs data, context, and style? Then use a composition: Haiku subagent + preloaded skill + one narrowly scoped MCP.

Composition formula: a Haiku subagent with a preloaded skill for conventions and a narrowly scoped MCP server for live data.

And the main rule for the direction of dependency: subagents can use MCP servers; MCP servers cannot use subagents.

In other words, MCP is always data and actions, not agents. If you want to delegate a task, that’s a subagent that calls MCP, not the other way around.

A specific example described here: a digital agency’s editorial engine that writes one SEO article in 60 minutes. Inside are 25 subagents and 14 review stages—they run sequentially, each with its own context, permissions, and skill for editorial conventions. One subagent connects to an MCP server with a database of ready-made tags and old articles. The main orchestrator agent runs on Opus; child agents run on Haiku, keeping the budget reasonable.

This is not an “article factory”; it is an example of how all four mechanisms combine into one system when the task calls for depth of quality rather than speed.

Which 7 Mistakes Should You Remove from Claude Code Right Now?#

1. Installed all top 10 plugins “because they’re trending.” Each adds tokens to every message. Open /plugin list and check each one’s Context cost. Remove the ones you haven’t used in two weeks.

2. Copied 15 MCP servers from someone else’s .mcp.json. Someone else’s stack is configured for someone else’s project and tasks. Keep no more than 2–3 active MCPs for the current project. Move the extras to a separate config for another project or delete them now.

3. The skill and MCP plugin do the same thing. The skill says “do a code review,” while the pr-review-toolkit plugin runs its own review flow. They start competing for priority. Symptom: “Claude, why do you keep going back and forth?” Solution: keep one source of truth. In the described setup, the skill was chosen to retain control over the instructions.

4. Using a skill for enforcement when you need a hook. A skill is a suggestion, not a guarantee. For “block .env in a commit,” a pre-commit hook can check that commit path. Test staged content and alternate paths separately; it does not prevent all reads or other publication routes. A skill alone cannot enforce that boundary.

5. A subagent with the same permissions as its parent. You gave it Opus and all the tools, and got another main session. The system prompt from the official documentation recommends giving a subagent a narrow tool list and its own constrained task. Otherwise, it’s just an expensive clone.

6. Didn’t check Will install before installing a plugin. In Claude Code v2.1.145+, this field shows the bundle’s complete contents. Often a plugin “for one little thing” contains three MCP servers, two subagents, and five hooks. They all start living in your context.

7. Old .claude/commands/ duplicate new skills. Anthropic says in its documentation:

The old commands/ folder still works, but skills are now the standard. In the described example, both folders were in use; commands/ was removed, leaving skills with bundled files and triggers.

Signs that Claude Code has become “cluttered”:

• Every message starts by mentioning available tools in 200+ lines.
• Simple tasks take longer than they did a month ago.
• Claude gets confused between two similar skills or plugins.
• Warnings about name collisions appear when a session starts.
• Claude calls the wrong tool—a skill A instead of MCP B, which was needed.

If you recognize at least two of these symptoms, open /plugin list and /skill list right now. First remove what you haven’t used in two weeks. Then check the Context cost for each item. After that, address the anti-patterns above.

How Many Skills and MCPs Can You Keep Without Burning Through the Context?#

What Claude Code shows directly:

• /skill list — all active skills and their token size.
• /plugin list — all plugins and their Context cost.
• /mcp list — MCP servers and their tool count.

Token budget in real numbers:

A context window is the maximum working space, not the number of tokens consumed by every task. Compare measured input, cached input, output, and repeated turns for the same result. Isolation can keep the parent context small while the subagent still incurs its own usage.

In its technical blog, Anthropic gives auto-compaction figures for skills: the first 5,000 tokens of each active skill are reattached, with a total budget of 25,000. This means that with more than 5 “heavy” skills active at once, Claude starts losing some instructions.

A simple practical rule:

• Skills: no more than 5–7 active for the current project. Put the rest in ~/.claude/skills/disabled/; if you need them, you can move them back.
• MCP: no more than 2–3 per project. Context7 for documentation is almost always worth having; keep the rest task-specific.
• Plugins: install strictly one at a time and check after two weeks whether you used it. If not, remove it.

A detailed analysis of Anthropic’s 2026 Agentic Coding Trends Report and why 80% of developers can’t fully delegate a task to Claude is in a separate guide. The main figure from that report: people use AI for 60% of their work, but fully hand off only 0–20% of tasks. The main reason is context overload and loss of control over tools.

Where Should a Beginner Start: The Minimal Working Setup?#

Minimal stack after two weeks of work:

1. CLAUDE.md at the root with project rules.
2. AGENTS.md for compatibility with other tools if you plan to work beyond Claude Code. More details in “How to Make One Instruction File for Claude Code, Codex, and Cursor”.
3. 1 skill for your main recurring task. For example, start with code-review according to your style guide.
4. 1 MCP server: Context7 for current documentation. Without it, Claude still hallucinates nonexistent APIs.
5. 0 plugins and 0 subagents in the first month. This isn’t about saving money; it’s about control. Until you understand the basics, bundles will confuse you.

From there, follow the tasks. A recurring procedure comes up? Turn it into a skill. Need live data from a specific service? Add MCP. A big task starts filling up the main context? Delegate it to a subagent.

That is the three-tier map: context first, then hand over to the system what you do more than a couple of times, then automated checks so the system doesn’t make mistakes on its own. Add each tier only when the previous one is already working.