I've been using the 187K-star superpowers for three months: it's not as great as you might think.

I've been using the 187K-star superpowers for three months: it's not as impressive as you'd think.

Three months ago, when I first encountered Superpowers, I was genuinely taken aback—installing 14 skills turned Claude Code into a complete software engineering pipeline, covering TDD, code review, and brainstorming. With 187K stars on GitHub, review articles touting "100x productivity gains," and engineers enthusiastically upvoting on the top HN thread.

After three months of use, the conclusion is: **it does have value, but not for everyone or every scenario**. In the entire Claude Code Skills ecosystem, there are far too many things where the packaging far outweighs the substance.

Background and Why It's Worth Paying Attention to Now

As of May 2026, there are over 1,400 Claude Code Skills on GitHub, with the official marketplace featuring more than 658. I have personally used 40+ of them and have helped my team clean up skill lists. The conclusion is clear: **no more than 10 truly make it into daily workflows**.

The technical principle is straightforward: a `SKILL.md` file with YAML frontmatter specifying the name and description, and Markdown instructions as the body, placed in `~/.claude/skills/` for immediate use. When Claude processes requests, it scans the names and descriptions of all skills using approximately 100 tokens to determine if they should be activated, and only loads the full content (usually less than 5k tokens) after activation. Adding 50 skills incurs only about 5000 tokens of overhead, which is a negligible cost.

But this also means anyone can write a skill in the afternoon, post it to GitHub, give it a catchy name, and rack up a bunch of stars. Someone tested 100 community skills, and 70% failed. The reasons for failure are highly concentrated: `SKILL.md` is too bloated (4000+ tokens), wasting context on irrelevant tasks; the description reads like marketing copy rather than routing rules, so Claude doesn't know when to activate it; single-file skills try to do everything, cramming five tasks into one skill without excelling at any; and there's no layering with reference files, with critical logic piled into `SKILL.md`, consuming a large chunk of context with each activation.

A good skill is precise: its description reads like a routing rule, not a marketing slogan; the core `SKILL.md` is concise, with details pushed to `references/` for on-demand loading; one skill does one thing. To judge whether it's worth installing, first read the first 50 lines of `SKILL.md`—if you finish them and still can't tell what it does, discard it.

Implications for Practitioners of Digital Products / Software Tools / AI

**superpowers：What Is the Real Experience**

Superpowers is the most successful skill collection in the entire ecosystem, from its release in October 2025 to now with 187K stars, v5.1.0 (updated May 4, 2026). It restructures Claude Code into a pipeline: brainstorming → writing-plans → executing-plans → requesting-code-review → verification-before-completion, with 14 skills covering the complete development lifecycle.

What does it actually change? With stock Claude Code, the typical failure mode for new features is: diving straight into code based on vague requirements, only to realize the direction is wrong after finishing, and then spending twice the time rewriting. Superpowers' brainstorming forces you to clarify your requirements before touching any code—not by pushing you to write documentation, but by asking a series of questions to uncover "what you actually want." In a controlled experiment across 12 sessions, half using it and half not, with tasks of equal complexity, the superpowers group saw a 14% reduction in token usage, and code quality (measured by PR review issues) improved significantly. The reason is intuitive: tokens spent during the planning phase are far cheaper than rewriting after going off track.

However, it has clear limitations. First, simple tasks are slowed down. "Help me write a regex," "add a console.log"—after being intercepted by brainstorming, it takes 10-20 minutes for the preliminary process, which is not worthwhile at all. HN engineers have reported that "Claude has become extremely verbose for simple tasks," which is a real issue. Second, the experience of modifying plans is poor. After generating a multi-page plan, if you want to change a small part, it regenerates the entire plan. As developers state: "You give it feedback, and it returns a completely new version of the multi-page plan, rather than just modifying the part you mentioned." Third, the TDD rule is too enforced on the model. It requires writing tests before implementation, and if there are no failing tests, it deletes the already-written code. The mechanism itself is correct, but the need to "get it running first and discuss later" during the exploration stage is genuine.

My final strategy is **selective activation**. For new features, refactoring, and modules with clear boundaries, I use the full workflow. For bug fixes, small feature additions, and one-off scripts, I use stock Claude Code directly. using-superpowers offers flexibility—you can install only brainstorming + systematic-debugging without the full suite.

**claude-mem: The Underrated One**

Superpowers gets the most discussion, but I think claude-mem is the most underrated. It solves a specific problem: Claude Code sessions are independent, so the design decisions, pitfalls, and naming conventions confirmed yesterday are all gone today. claude-mem's approach: at the end of a session, it compresses valuable content into 'memory fragments' and stores them locally (SQLite + Chroma vector database). At the start of the next session, it automatically retrieves relevant memories and injects them into the system prompt. Currently 72.4K stars, v12.6.4 (May 2026), 259 releases, and 109 contributors.

Its most valuable aspects: for multi-day iteration projects, you don't have to re-explain "We use PostgreSQL, not MySQL, because..." the next day; pitfall records automatically surface; team norms, once stated like "function naming uses verb + noun," don't need to be repeated endlessly.

Real limitations: The biggest risk is **memory noise**. It remembers everything, including incorrect assumptions, temporary decisions, and plans that were later overturned. Without regular cleanup, the "relevant memories" retrieved can actually mislead Claude. I've fallen into this trap—during a temporary test, I said "let's try this for now," and claude-mem remembered it. For the next several sessions, Claude kept referencing this "temporary plan" in its work, and it took a long time to figure out what was going on. Additionally, it cannot replace code comments and documentation. Stable architectural decisions should be written into CLAUDE.md and code comments, not just live in the memory store—memories can expire, get overwritten, or become ambiguous, but code comments won't. The right approach: treat claude-mem as an "enhanced index for conversation records," not a "replacement for the architecture knowledge base."

**agent-browser: Use This for Browser Automation**

Let Claude Code operate the browser. Mainstream options in 2026: agent-browser (200-400 tokens/page, daily browsing, forms, navigation, low installation complexity), Playwright MCP (2000-6000 tokens/page, complex DOM interactions, medium installation complexity), Playwright CLI (about 1/4 of MCP, coding agent optimized version), Chrome DevTools MCP (medium, screenshots, debugging).

agent-browser has only one advantage, but it's a critical one: **the highest token efficiency**. It represents page state using a concise YAML summary instead of dumping the entire DOM tree, requiring only 200-400 tokens per page. For everyday tasks like "navigate to a page, find elements, extract data," it's both sufficient and inexpensive. With 253K+ installations (top five in the ecosystem), user feedback is consistent: daily

Source

Source: https://juejin.cn/post/7689018123110957096