6 Claude Code Skills That Actually Sell to

There's a particular kind of YouTube video that promises to cut through the hype, then delivers its own variety of it. Nate Herk's recent breakdown of Claude Code skills mostly avoids that trap—but "mostly" is doing real work in that sentence, and I'll flag where the numbers deserve more scrutiny than they got.

The core argument is worth taking seriously: after what Herk describes as 400 hours working with Claude Code across clients in real estate, HVAC, coaching, and marketing, he found that businesses keep paying for the same six types of tools. Not the flashy ones. Not the ones that make good demo videos. The boring, reliable ones that save time, cut errors, or compress costs.

"Most people online are developing fancy skills for the sake of a cool video," Herk says, "but businesses don't actually want that."

That's a useful corrective to a lot of AI content, where capability demonstrations substitute for practical guidance. So let's walk through what he actually found.

The Six (Plus the Caveats)

Skill Creator is Herk's first install on any project—and it's an official Anthropic plugin, which matters for reliability. The premise is simple: instead of hand-coding skill markdown files (and frequently breaking them), you describe what you want in plain English and the plugin handles drafting, testing, and packaging. Herk's framing is apt: "It's the factory that builds the product." You're not selling the Skill Creator to a client—you're using it to build everything else you will sell them. This one is straightforward, well-supported by Anthropic directly, and the least likely entry on this list to come with asterisks.

Superpowers forces Claude to behave more like a senior developer: plan first, write tests before code, review output twice (once for spec compliance, once for code quality), and work in an isolated environment so nothing bleeds into your main project. The problem it's solving—Claude sprinting to write code that looks fine until a client touches it—is real and well-documented by anyone who's used Claude Code for more than a few sessions.

Here's where I need to pump the brakes slightly. Herk cites "over 150,000 GitHub stars" as evidence of Superpowers' popularity. That number is unverified—I couldn't independently confirm it before publication—and GitHub star counts can be inflated, duplicated across forks, or simply misremembered. The plugin may well be genuinely popular; the methodology behind that specific figure just isn't something I'd stake on without a direct check. If you're evaluating Superpowers, look at the repo yourself rather than treating any cited star count as authoritative.

GSD (Get Shit Done) addresses something Claude Code users hit eventually: context rot. You start a session strong, Claude is nailing everything, and then somewhere past the halfway mark of your context window, quality degrades. Claude starts forgetting requirements, cutting corners, telling you things are done when they aren't. GSD's fix is architectural—it spawns fresh sub-agents for individual tasks, each with a clean context window, rather than letting one long session slowly fall apart. It also includes quality gates for scope drift and security verification that most developers wouldn't manually check, especially those without a software engineering background. Herk is upfront that GSD isn't a token-saving tool—the sub-agents cost tokens—but what it buys you is hours you'd otherwise spend redoing broken work.

The /review and /ultra review commands are already baked into Claude Code; you're not installing anything. /review runs a structured local code review—fast, free beyond standard token usage, catches bugs and edge cases. /ultra review is more ambitious: it uploads your branch to a cloud sandbox and runs parallel reviewer agents from different angles (logic, security, performance), with the requirement that any flagged bug be independently reproduced before it surfaces on your list. Confirmed bugs only, no false positive pile-ups.

A few verification flags on this one. Herk attributes /ultra review to launching "alongside Opus 4.7"—but Anthropic's publicly documented model versioning doesn't include a 4.7 designation as of my knowledge. That version number may be speculative, misremembered, or refer to an internal designation not reflected in public releases. I'd treat it as an unverified detail. Similarly, the pricing Herk cites—three free runs for Pro and Max subscribers, then roughly $5-20 per run depending on project size—comes with his own caveat that it "might have changed by the time you're watching this." That's honest, but it also means you should check Anthropic's current pricing documentation directly before budgeting around it. Don't let a YouTube video be your source of truth on subscription costs.

Context Mode tackles a related but distinct problem: Claude dumps raw data into your context window with every tool call, and after about 30 minutes of real work, a significant chunk of that window is noise—log output, raw snapshots, data you never needed Claude to read in the first place. Context Mode routes tool calls through a sandbox, captures the raw output, and feeds only the relevant summary back into the context window. It also tracks session events in a local SQL database, so when Claude has to compact the conversation, it can rebuild a snapshot and pick up where things left off.

The compression numbers Herk cites—315 kilobytes of raw output compressed to 5 kilobytes over a full session—come from the Context Mode developers' own published benchmarks. That vendor is mksglu (the plugin's GitHub author, based on the install command mksglu/context-mode). Self-published benchmarks from a tool's own creator should be read as aspirational rather than independently verified. They may well be accurate; they may represent best-case conditions. You can run /contextmode:ctx-stats during your own sessions to see numbers specific to your actual usage, which is a better basis for evaluation than any marketing figure.

ClaudeMem closes the loop that Context Mode opens. Context Mode keeps your current session clean; ClaudeMem carries knowledge across sessions. Claude Code starts every new session from scratch—no memory of what you've built, decided, or debugged. ClaudeMem hooks into the session lifecycle, automatically captures file edits, decisions, bug fixes, and key commands, compresses them into semantic summaries using Claude's agent SDK, and stores everything in a local SQLite database with vector search. When you open a new session, relevant context gets injected back in automatically.

The repo claims roughly 10x token savings on retrieval compared to dumping full session history into the context at startup. This figure is self-reported by the tool's creator (thedotmack, per the install command), and I'd treat it as directional rather than established—there's no independent testing I'm aware of to validate it. The underlying mechanism (tiered retrieval rather than bulk injection) is architecturally sound as a concept; the specific 10x figure is marketing until someone runs a controlled comparison.

One practical installation warning Herk flags that's worth repeating: don't run npm install on ClaudeMem. It installs the SDK library without registering hooks, so nothing actually works. Use the two plugin marketplace commands instead.

The Business Case, Such As It Is

The last section of Herk's video pivots to selling this stack to clients, and his advice here is less about the tools than about framing. "You need to be selling the outcome," he says. "Saving the business owner 10 hours a week or cutting their admin mistakes and their human error."

This isn't controversial advice—it's Sales 101 dressed in AI clothing—but it's worth noting because the specific skills he's recommending aren't what you're actually marketing. A real estate agency doesn't want to hear about context windows and sub-agent spawning. They want to stop wasting hours writing property descriptions. The skills are the mechanism; the pitch is the result.

What Herk is essentially describing is a workflow stack: Skill Creator to build custom tools, Superpowers to ensure Claude plans before it codes, GSD to keep context clean during execution, /review and /ultra review to catch what Claude misses, Context Mode to compress noise during sessions, and ClaudeMem to preserve knowledge across sessions. Each one addresses a specific failure mode. Together they're meant to make Claude Code reliable enough to put in front of a paying client without holding your breath.

Whether that stack actually delivers in your specific use case depends on variables no YouTube video can account for—your project complexity, your client's tolerance for edge cases, your own QA practices. The tools are real. The benchmarks deserve skepticism proportional to their source. The failure modes they're designed to fix are genuine.

That's a reasonable starting point. Just verify the numbers yourself before you quote them to anyone.

Rachel "Rach" Kovacs is Buzzrag's cybersecurity and privacy correspondent.