Your Claude Code stack matters more than your model choice. I will defend that claim all day: the gap between a well-tooled setup and a vanilla one — real code intelligence, live docs, browser hands, a second model checking the first — is larger in practice than the gap between any two frontier models this year. A smarter model cannot save a blind agent.
The credential behind this particular top-10 is that it is a surviving ten, not a curated ten. My plugin file currently lists 24 installs; my skills directory has passed thirty entries; I have built and maintain a 53-skill marketplace and have therefore tested more of this ecosystem than almost anyone whose job is not literally this. What follows is what is still standing after real client work — grouped honestly into skills, plugins, and CLIs, because the three categories solve different problems and most lists blur them.
The skills (judgment, encoded)
1. Superpowers. The workflow-discipline family: brainstorm before building, test-driven development, systematic debugging, verify before claiming done. This is the single install that most changes session behavior — the agent starts gating its own work. Every other entry on this list makes Claude more capable; this one makes it more trustworthy. If you install one thing today, it is this.
2. skill-creator. The meta-skill that scaffolds, tests, and packages new skills. It matters because the endgame of the whole ecosystem is not installing other people's skills — it is cheaply encoding your own judgment. Everything custom in my stack, including the SEO skill family that ran this blog's indexation remediation, started from this scaffold. My deeper reasoning about which foundation skills to start with is in the skills worth installing right now.
3. caveman. Compresses verbose agent output to cut token burn on long sessions. It reads like a joke and bills like a utility — on multi-hour sessions the savings are structural, not marginal. It stays because I measured it.
4. handoff. Packages session state — decisions, touched files, open threads — so tomorrow's session starts warm. Multi-session amnesia is the most underrated tax in agent-assisted work, and this is the cheapest treatment for it that actually works.
The plugins (capability, wired in)
5. Codex — the adversarial second opinion. OpenAI's model, running as a reviewer inside Claude Code, in a separate process. The value is the disagreement: findings both models flag are nearly always real bugs; findings they split on tell you where your code is genuinely ambiguous. Running a rival model as your reviewer sounded absurd until I tried it; now it is my standard pre-merge step. Full pattern in Codex as adversarial reviewer.
6. Language Server plugins (PHP LSP / TypeScript LSP). Real code intelligence — definitions, references, diagnostics — instead of grep-and-infer navigation. These are the quietest tools on this list and possibly the highest-yield: they produce no visible output, just fewer wrong edits. On a Laravel codebase the PHP LSP pays for itself daily; swap in your language's server.
7. Context7. Version-accurate library documentation pulled into context on demand, so the agent works from the API that exists rather than the one in its training data. Where it earns its slot: fast-moving packages, framework majors, anything you would otherwise verify by hand.
8. Playwright + Chrome DevTools MCP. Browser hands and browser eyes. The agent navigates real pages, fills forms, reads consoles and network requests, and screenshots results — which turns "I changed the UI" into "I changed the UI and verified it renders." For frontend work this closes the loop that pure code generation leaves open. My Playwright CLI browser automation writeup covers the scaling patterns.
The CLIs (leverage the agent inherits)
9. gh (GitHub CLI). Not an AI tool at all, and top-three in my stack by usage. Claude Code drives any CLI you have installed, so gh gives it PRs, issues, checks, and releases without a browser or an API integration. The general principle matters more than this specific tool: every scriptable CLI on your machine is already an agent capability. Audit your PATH before you audit the marketplace.
10. Laravel Boost (project MCP). My project-level example of the same principle: an MCP server in this repo's .mcp.json exposing routes, schema, config, logs, and a tinker surface. Every session in this codebase starts already knowing the application. Whatever your stack, the pattern generalizes — the best tenth tool in your list is the one that teaches the agent your project's ground truth. Substitute your framework's equivalent.
What did not make the ten
Credibility requires the reject pile. Installed and idle on my machine: a Go LSP for a language I touch quarterly, two design-tool experiments, a memory plugin whose job my CLAUDE.md and handoff skill already do, and several marketplace darlings that demoed beautifully and never triggered again. The pattern behind most failures is overlap — two tools claiming the same job means the agent picks unpredictably, so one of them has to go. A stack is a system, not a collection; every addition taxes every session whether used or not.
The decision framework: which of these do you actually need?
Do not install ten tools. Map your friction first:
- Agent makes plausible-but-wrong edits in your codebase → LSP plugin for your language (#6), then a project MCP (#10).
- Agent confidently uses APIs that no longer exist → Context7 (#7).
- You do not trust the agent's "done" → Superpowers (#1), then Codex review (#5).
- Long sessions bleed tokens and coherence → caveman (#3) and handoff (#4).
- Frontend changes you cannot verify without alt-tabbing → Playwright/DevTools (#8).
- You keep re-typing the same instructions → that is a custom skill, and skill-creator (#2) is how it gets built.
- You live in GitHub →
gh(#9) is a five-minute install with zero downside.
Two tools from that mapping, run for two weeks, will beat all ten installed in an afternoon. Retention discipline — removing what has not visibly earned its context cost — matters more than selection, which is the thesis of my full plugins-I-actually-use rundown if you want the plugin layer examined on its own.
Where this is heading
The trajectory I see from the marketplace side: the skills layer is professionalizing fastest — families of narrow, well-triggered skills beating mega-skills — while the plugin layer consolidates around a few load-bearing categories (LSPs, docs, review, browser). The CLI layer never needed to professionalize because it was already there; agents just made forty years of Unix tooling newly relevant. When your basics stabilize, the advanced skill techniques — context forking, background execution, dynamic injection — are the next tier, and I keep the advanced agent skills playbook current for exactly that graduation.
The stack in this post took months of install-test-remove cycles to settle, and it will drift again by next year. What will not drift is the method: friction first, one tool at a time, ruthless removal. That method is the actual top-10.
Alongside the tools, the other half of my daily leverage is a library of battle-tested prompts for exactly these workflows — review passes, refactors, audits — all free to lift from my prompt library.
