There are dozens of add-ons for Claude Code, but only a handful matter in day-to-day work. I've picked the six I rate highest — not the flashiest, but the ones that save time, cut cost, and catch mistakes before they reach a client. Here's each in turn: what it does and when to switch it on.
Two terms first. Claude Code is a tool where Claude works on coding and operational tasks — it runs in the terminal, reads files, executes steps. A skill is a package you install to teach Claude to do one specific task better. Some of the ones below are, strictly speaking, plugins — larger packages that bundle more than just the skill, such as an MCP server (the way Claude connects to outside tools and data). The naming difference is secondary here: every one of these add-ons makes Claude noticeably better at its job.
1. Skill Creator — the factory that builds every other skill
This is the skill that all the others come out of. It's one of Anthropic's official add-ons. You describe what you need in plain language, and Claude lays out the skill, tests it, fixes it, and packages it into something you can reuse. You don't have to edit files by hand or know the formatting — you talk to Claude as if you were briefing a colleague, and you walk away with a finished skill that behaves the same way every time. You can even hand it a ready-made standard operating procedure (SOP) and it'll turn that into a working skill.
The problem it solves is simple. Most people try to write skills by hand and hit a wall immediately: they don't know the structure, and they can't tell a solid skill from one that falls apart the moment a client touches it. Skill Creator takes that headache away. It isn't a product a client pays for on its own — but every skill you go on to sell comes out of it. It's the factory that builds the product.
A concrete example: a real-estate agency loses a few hours a week writing listing descriptions. Without Skill Creator you'd build the whole skill file yourself, work out the trigger conditions, and test it over and over. With it, you just describe the task naturally and it helps you build, test, and package the solution. It's worth installing once, globally — then it fires on its own, in any project, the moment you need to build a new skill.
2. Superpowers — Claude works like a seasoned engineer
This skill forces Claude into the working style of a seasoned engineer. Instead of writing code straight away, Claude first steps back and plans the whole thing. It works in an isolated environment, so it breaks nothing in the main project. It writes tests before it writes code. It brainstorms and reviews its own work in two passes: once for compliance with the spec, once for code quality.
This solves the most common problem in working with Claude Code: rushed, sloppy code. You ask for something, Claude writes it on the fly, it looks fine at first glance — and then it falls apart the moment you start using it. Or worse: it falls apart at the client's. Superpowers slows Claude down just enough to actually think the problem through, and it won't let it skip steps.
Any project that ships to production — a ticketing system for an installation company, a reporting tool for an agency — needs this kind of approach. The client doesn't care how many lines of code it took; they care that the system works when their business depends on it. Without a framework like Superpowers, Claude might write the whole thing in one go and miss an edge case. With it, Claude plans, writes tests, finds those cases, and catches the gaps before they reach the client.
It isn't that everything lands on the first attempt. A good chunk of the work is still quality control on your side. But to my mind, if the first attempt delivers 80 percent instead of 60, that's already a win — fewer rounds of fixes means less time spent repairing and a lower token cost (a token is a chunk of text the model operates on; the more you burn, the more it costs). It's also one of the community's most popular skills, with over 150,000 stars on GitHub.
3. GSD — a clean environment for longer work
If Superpowers is about how Claude writes code, then GSD (short for "get it done") is about the environment Claude works in. Every Claude Code user hits this wall sooner or later: a session goes great, and then somewhere around the middle of the context window it starts to fall apart. The code gets sloppy, Claude forgets the requirements set at the start, skips steps, and sometimes declares a task finished when it isn't. This phenomenon is called context rot — the context window being the amount of text the model "sees" at once: instructions, files, the conversation so far.
GSD solves this through context engineering. Rather than letting one long session slowly degrade, it spins up fresh helper agents for each task — an agent being a self-contained "worker" that gets a clean context window and only the information it needs. The main session stays orderly, and every task has the full power of the context window at its disposal, not the leftovers.
It also has built-in quality gates that catch real problems mid-flight. Scope-creep detection stops the planner when it quietly drops a requirement you asked for. Security enforcement ties verification to your threat model. These are things that are hard to police on your own, especially without an engineering background — which is why automating them matters. There's also an autonomous mode: you hand over a spec and walk away, and GSD plans, executes, and signs off on the work without constant supervision. One thing worth being honest about: GSD doesn't save tokens — all those helper agents cost. What it saves is the hours that would otherwise go into redoing work that broke because Claude forgot what you asked for.
4. /review and /ultra review — code review built into the tool
You don't install the fourth one — it's already built into Claude Code, and most people don't use it. It's the /review command and its heavier counterpart, /ultra review. When you finish writing code and type /review, Claude runs an orderly review of what it produced: it looks for bugs, edge cases, and design problems. It runs locally, it's fast, and it costs nothing beyond ordinary token usage.
/ultra review works differently. It sends your code branch to a cloud test environment and runs a whole squad of reviewer agents there in parallel. Each one attacks the code from a different angle: logic, security, performance, edge cases. The key part: before any bug makes the list, it has to be independently reproduced and confirmed. So what you get is confirmed bugs, not a pile of stylistic nitpicks or false alarms.
Two things before you run it. /ultra review requires Claude Code version 2.1.86 or newer and a logged-in Claude account — an API key alone won't do. A run can take 10 to 20 minutes, but it happens in the background, so you can keep working. In practice you use /review on the fly for quick feedback, and /ultra review before merging something that really matters — a big rebuild, or a change touching payments, login, or the database, where a bug in production costs more than the run itself. The Pro and Max plans give you three free runs to try it out; after that a run can cost anywhere from $5 to $20 depending on size (check the pricing at the source — it gets updated).
5. Context Mode — less clutter in the context window
The problem is this: every tool call dumps raw data into the context window. A page scrape can take up 56 kilobytes; twenty issues from a repository, 59 kilobytes. After about thirty minutes of real work, 40 percent of the context window is clutter: logs, raw output, things Claude never needed to look at. And when space runs out and the conversation gets compacted, Claude forgets which files it edited, which tasks were in flight, and what you last asked it for.
Context Mode solves both halves of this. First, it keeps the clutter out. When Claude runs a command or fetches a URL, Context Mode routes that call through an isolated environment: the code runs separately, the raw output is captured, and only the part Claude actually needs comes back into the context window. According to the maker's tests, a 56-kilobyte page scrape shrinks to 299 bytes, and a 46-kilobyte access log to 155 bytes; across a whole session, 315 kilobytes of raw output turns into 5 kilobytes. You can check your own figures with the /contextmode:ctx-stats command.
Second, Context Mode records every significant session event in a local database: every file edited, every task created, every decision, every error. When the conversation gets compacted, none of it is lost — Context Mode restores a snapshot of the session and injects it back in, so the model picks the work up exactly where you left it. In practice, sessions that used to fall apart after thirty minutes now run for several hours, and you stop wasting prompts reminding Claude of context it already had. Installation comes down to two commands and a restart — the plugin adds the MCP server, the hooks, and the routing rules itself.
6. ClaudeMem — memory between sessions
If Context Mode keeps order within the current session, ClaudeMem carries knowledge across all the ones that follow. Claude Code starts each new session from scratch — you open it and, for the fifth time that month, explain the same project, losing a few minutes and thousands of tokens to the briefing every time. Claude.md files and memory files help here (these are plain text files holding persistent instructions for the project), but you have to maintain them by hand — miss an update, and Claude misses it too.
ClaudeMem takes that on. It hooks into the session lifecycle and records what happened on its own: file edits, decisions, bug fixes, commands. It then compresses all of it into concise summaries and stores them in a local database with semantic search (by meaning, that is, not just exact words). When you open a new session, the relevant pieces come back automatically. Along the way, ClaudeMem creates and updates Claude.md files at the folder level — your project documentation writes itself, in the background.
What saves tokens here is how the data gets retrieved. Instead of dumping every old note into context, ClaudeMem uses three-layer retrieval: first it returns a concise index of events, then it lets you pull the timeline around the relevant ones, and only at the end does it fetch the full details. The repository reports roughly a tenfold token saving on retrieval compared with dumping everything in at the start. In practice you stop paying the "startup tax" on every new session, and you come back to a project after two weeks to find Claude already knows what you're working on and what you decided. One warning straight from the repository: don't run npm install — it installs the library itself, and nothing will work because the hooks won't register. Stick to the two commands from the plugin's installer.
One bonus skill, and a closing thought
Beyond the six, there's also Anthropic's official front-end design skill. It's worth installing globally — it makes what you design in Claude Code look less "AI-generated."
One last thing that's easy to overlook when choosing tools. The client doesn't buy a skill or a workflow — they buy the result: ten hours a week back on the books, fewer slip-ups, queries handled faster. If you're just starting out, my advice is not to reach for all six at once. Pick one skill, learn it, build a few solutions on it, and show a working demo. That demo, not the number of add-ons you've installed, is what tells you whether a tool is worth the trouble.