9 Claude Code Plugins Worth Installing — A Field Report

Claude Code is smart enough out of the box. But after six months of daily use, you notice the same frustrations repeating themselves.

• "It's giving me an old version of the library API again."
• "Tired of asking for a code review by hand every time."
• "Do I really have to copy-paste this Notion page in?"
• "I said tests first and it went to implementation again."

Plugins are the answer to each of these. With a few good ones installed, Claude stops being a generic smart assistant and becomes a teammate that has learned how you work.

This is a field report — after a year of installing, removing, and reinstalling — on the 9 plugins that ended up in every project I touch.

What's a plugin, and why bother

A Claude Code plugin bundles up to four things:

1. Skills — procedural playbooks Claude auto-invokes for specific tasks
2. Agents — sub-agents with a specific role (code-reviewer, planner, etc.)
3. Slash commands — user-invoked shortcuts (/review, /plan)
4. MCP servers — external tool connectors (Notion, Figma, Playwright, DB, etc.)

A plugin can ship just one of these, but the good ones combine two or more.

Installation is one line:

/plugin install <plugin-name>

Or you can add a marketplace and manage as a set:

/plugin marketplace add <github-url>
/plugin install <plugin-name>@<marketplace>

1. superpowers — process discipline for every task

If you've ever told Claude "let's do TDD" in the prompt and watched it go straight to implementation anyway.

Obra's superpowers changes how Claude works, not just what it knows. The core unit is "skills" — guardrails that force Claude to stop falling into the same traps.

The ones that fire most often:

• brainstorming — required before starting a new feature. Blocks the rush to code.
• test-driven-development — tests first, implementation second. Every time.
• systematic-debugging — bugs get the hypothesis → reproduce → fix sequence.
• verification-before-completion — actually verify before claiming "done."

The first thing you notice — Claude becomes less confident, more careful. Annoying for a week, then you realize this is what code that doesn't break looks like.

/plugin install superpowers

2. everything-claude-code — the all-in-one bundle

everything-claude-code is exactly what it sounds like: 200+ skills, 30+ agents, 50+ slash commands.

Looks like too much at first. The ones you actually use settle out fast:

Agents:

• planner — produce a plan before any large change
• code-reviewer — review after every meaningful edit
• tdd-guide — TDD enforcement (overlaps with superpowers, more detailed)
• security-reviewer — secrets, injection, OWASP checks
• build-error-resolver — debug broken builds

Slash commands:

• /plan — write a plan doc before a big change
• /code-review — comprehensive review of current changes
• /security-review — security audit
• /save-session — save current session, resume later with /resume-session
• /learn — extract reusable patterns from a session

Skills:

• Per-language conventions (frontend-patterns, backend-patterns, python-patterns)
• Meta plugin development (claude-api, mcp-server-patterns)
• Non-code work (article-writing, frontend-slides)

Most workflows are in here. If you only install one thing, this is defensible.

/plugin install everything-claude-code

3. context7 — live library docs

One of Claude's biggest weaknesses — knowledge cutoff. It doesn't know library changes after its training data ended. Next.js 16's new APIs, React 19 hook changes, Tailwind v4 config — none of it. So it confidently gives you yesterday's code.

Context7 solves this by fetching official docs in real time and feeding them to Claude.

Usage is implicit — it auto-fires when libraries come up. Or be explicit:

"How do I configure turbopack in Next.js 16? Use context7."

This one plugin alone cuts hallucinations roughly in half. Especially valuable for:

• Recent major version bumps
• SDKs that change frequently (Stripe, Supabase, Firebase)
• Frameworks with strong official docs

/plugin install context7

4. playwright — browser automation and UI verification

The biggest UI-work trap — "it says it works but the browser disagrees." Type checks pass, tests pass, but click around and it's broken.

The Playwright MCP plugin lets Claude launch a browser, click, screenshot, and read the console itself.

Patterns I use weekly:

"Open this page at mobile size, screenshot the hero section,
and check the console for errors."

"Walk through login → dashboard → settings and tell me
if anything breaks in the middle."

E2E tests too — Claude writes them and runs them. "I clicked through the PR myself" becomes automated.

/plugin install playwright

5. code-review — /review in one shot

A small plugin I use daily. /review runs a comprehensive review of the current branch (or a specified PR).

What it checks:

• Code quality, naming, abstractions
• Security (secrets, injection, authz)
• Test coverage
• Doc/comment consistency
• Performance traps

My actual workflow:

# work done
git commit -m "feat: ..."
 
# self-review before push
/code-review
 
# fix what it caught — missed input validation here
git commit --amend
 
# push
git push

You catch your own embarrassing parts before anyone else does. PR comments dropped roughly 30% in my repos.

/plugin install code-review

6. figma — design context, not just screenshots

A Figma link from a designer used to mean opening it in a tab and hand-translating to Tailwind. That era's over.

The Figma MCP plugin gives Claude the actual design context: colors, spacing, fonts, component structure, design tokens — all of it.

"Implement this node as React + Tailwind in this project's style:
https://figma.com/design/abc123/...?node-id=1-2"

The trick — don't ship Claude's output verbatim. Treat it as a starting point, then adapt to the project's component system. The plugin gets you 80% there; the last 20% always needs your hands.

The standout features:

• Code Connect — map Figma components to code components. Designer uses "Button" → Claude inserts your <Button>.
• get_screenshot — visual confirmation of what the node actually looks like.

/plugin install figma

7. Notion / Slack / Gmail / Atlassian — workspace integrations

Grouping these four because they all follow the same pattern. All are official Anthropic MCP integrations.

Notion — meeting notes, specs, tickets:

"Pull this sprint's tasks from our 'Roadmap Q2' page,
filtered to the ones assigned to me."

Slack — channel search, message sending:

"Summarize yesterday's deploy-related conversation in #engineering."

Gmail — email search, drafts:

"Draft a follow-up to investor X based on our last thread."

Atlassian (Jira/Confluence) — issue management:

"Show my Jira issues this week by priority,
with rough time estimates each."

The real value of all four — stop coding with context scattered across tabs. "Where was the spec for this again?" disappears.

8. supabase — database in natural language

The annoying parts of DB work — opening a SQL console, checking schemas, writing migrations, applying them. The Supabase MCP plugin lets you skip the console:

"Add a 'subscription_tier' column to the users table.
Enum (free, pro, enterprise), default 'free'.
Add an RLS policy so users can only read their own row."

It generates the migration → shows you the SQL → applies on approval. It also nudges you on easy-to-forget security like Row Level Security.

Not on Supabase? Postgres MCP, Prisma MCP, and others fill the same role. One DB MCP belongs in your kit.

/plugin install supabase

9. expo — React Native and mobile builds

If you ship mobile, Expo's MCP plugin is close to mandatory.

What I use most:

• EAS workflow YAML — describe the CI/CD pipeline in natural language
• dev client builds — TestFlight upload automation
• Tailwind setup — NativeWind v5 config in one shot
• Expo Router guidance — file-based routing patterns

The killer feature — Expo SDK upgrades. The annual ritual where everything breaks now has Claude resolving dependency conflicts one by one.

/plugin install expo

What NOT to install — and the install-time checklist

More plugins is not better. They eat context, and they sometimes conflict.

Three checks before installing:

1. Will I use this 5+ times a month? If not, skip it. A plugin you used once and forgot still occupies the system prompt.
2. Does it overlap with something already installed? Superpowers' TDD skill and everything-claude-code's tdd-guide agent do the same job. Pick one.
3. Under 100 GitHub stars? Read the code. Plugins modify the system prompt and add tools. Malicious plugin probability is small but nonzero.

My setup — for reference

I get asked, so — current global install:

/plugin install superpowers
/plugin install everything-claude-code
/plugin install context7
/plugin install code-review
/plugin install playwright

Per-project additions:

• Web work → figma
• Backend work → supabase (or another DB MCP)
• Mobile → expo
• Day job → notion, slack, atlassian (personal accounts only)

That's it. 5–8 plugins total. More plugins doesn't make Claude smarter, it makes it more confused.

Closing — what matters more than plugins

Before any of this — write a good CLAUDE.md.

A well-written one-page CLAUDE.md makes a bigger difference than 30 plugins. Conventions, directory layout, common commands, traps to know — write these down clearly and Claude knows how to work in your project even with zero plugins.

Plugins are accelerators on top of that foundation. Fundamentals first, plugins second. Don't reverse the order.

Next post — how to write a CLAUDE.md worth its weight.