Six Claude Code skills — a cheat sheet

This is the version to keep at hand. It gathers the six Claude Code skills from the article into one place: what each one does, how to run it, and what to watch for when installing. Open it when you're deciding what to turn on in a project, or when you don't remember the exact command.

Two words of background. A skill is a package you install so Claude does one specific task better. Strictly speaking, some of what follows are plugins — larger packages that bundle extras like an MCP server alongside the skill. The naming difference doesn't matter much here.

Six skills at a glance

Plus one extra beyond the six: Anthropic's official skill for front-end design — worth installing globally, it makes what you design look less "AI-generated."

1. Skill Creator

• What it does. From a plain-language description, it puts together a skill, tests it, refines it, and packages it for reuse. Hand it a working procedure (an SOP) and it turns that into a working skill.
• Why it matters. Most people try to write skills by hand and hit a wall — they don't know the structure. Skill Creator removes that problem: it's the factory every other skill comes out of.
• How. Official Anthropic add-on. Install it once, globally — it then fires on its own in any project when a new skill needs building.

2. Superpowers

• What it does. Forces Claude into an experienced developer's workflow: plan first, work in an isolated environment, tests before code, a brainstorming pass, and a two-stage review at the end — once for spec compliance, once for code quality.
• Why it matters. It solves the most common problem with Claude Code: rushed code that looks fine and falls apart in use, or at a client's hands. It slows Claude down enough to think the problem through instead of skipping steps.
• What to expect. Not everything lands on the first pass; some of the work is still quality control on your end. But if the first pass delivers 80 percent instead of 60, that's already a win — fewer correction cycles means a lower token bill.
• How. One of the most popular community skills — over 150,000 stars on GitHub.

3. GSD

• What it does. This is about the environment Claude works in, not the coding style itself. It spins up a fresh helper agent with a clean context window for every task, so the main session stays organized and each task gets the full context budget.
• Why it matters. It counters context rot: code degrades, Claude forgets requirements, skips steps, or calls a task done when it isn't.
• Quality gates. Scope-creep detection stops the planner when it quietly drops a requirement. Security enforcement ties verification to your threat model.
• Autonomous mode. Hand it a spec and walk away — GSD plans, executes, and signs off the work without constant supervision.
• The limit. GSD doesn't save tokens — every helper agent costs. What it saves are the hours you'd otherwise spend redoing broken work.

4. /review and /ultra review

You don't install this — it's already built into Claude Code, and most people never touch it.

• What /review does. A structured code review: it looks for bugs, edge cases, and design problems.
• What /ultra review does. It sends your branch to the cloud and runs a group of reviewers, each from a different angle: logic, security, performance, edge cases. Before a finding makes the list, it has to be independently reproduced and confirmed — you get confirmed bugs, not a pile of false positives.
• Requirements for /ultra review. Claude Code 2.1.86 or later, and a Claude account login — an API key alone won't do it.
• Time and cost. A run can take 10 to 20 minutes, but it happens in the background. Pro and Max plans include three free runs to try it; after that a run can cost 5 to 20 dollars depending on size (check current pricing at the source — it does get updated).
• When. Run /ultra review before a major rebuild or a change touching payments, auth, or the database — anywhere a production bug costs more than the run itself.

5. Context Mode

• What it does (first half). Keeps clutter out of the context window. When Claude runs a command or fetches a URL, Context Mode routes the call through an isolated environment: the raw output gets captured, and only the part Claude actually needs comes back.
• What it does (second half). Logs every meaningful session event to a local database — files edited, tasks created, decisions, errors. When the conversation gets compacted, Context Mode replays a session snapshot and injects it back in, so the model picks up exactly where you left off.
• The vendor's numbers. Per the maker's own benchmarks, a 56-kilobyte page dump shrinks to 299 bytes, and a 46-kilobyte access log to 155 bytes; across a session, 315 kilobytes of raw output becomes 5 kilobytes.
• Checking your own numbers. Run /contextmode:ctx-stats.
• Install. Two commands and a restart — the plugin adds its own MCP server, hooks, and routing rules.

6. ClaudeMem

• What it does. Carries knowledge across sessions. It hooks into the session lifecycle and logs what happened on its own: file edits, decisions, bug fixes, commands. It compresses that into summaries and stores them in a local database with semantic search. On a new session, the relevant pieces come back automatically.
• The docs write themselves. ClaudeMem creates and updates Claude.md files at the folder level on its own, in the background.
• Where the token savings come from. A three-tier retrieval: first a compact event index, then a timeline around the events that matter, and only then the full detail. The repo claims a roughly ten-to-one reduction in retrieval tokens compared with dumping everything in at the start.
• A warning from the repo. Don't run npm install — it installs the bare library and nothing works, because the hooks never register. Stick to the two commands from the plugin's installer.

Where to start

The article advises against reaching for all six at once. The order follows its own recommendations:

1. Pick one skill and learn it, instead of installing everything at once.
2. Build a few things on it and show a working demo — that's what tells you whether the tool is worth the effort, not the number of add-ons installed.
3. Install Skill Creator globally, once — every other skill comes out of it.
4. Front-end design is also worth having globally if you design interfaces.

A client doesn't buy a skill or a workflow — they buy the outcome: ten hours a week back, fewer mistakes, requests handled faster.