I Installed 50 Claude Code Skills. Only 20 Survived the Purge.

Six months into the Skill ecosystem, I've gone through three phases.

The first month: I installed everything I saw. I installed half of what was on the homepage of awesome-skills.com alone, feeling like I was about to take off. The second month: I discovered the .claude/skills/ directory was stuffed with over 50 folders, but Claude was actually using no more than 5 of them daily. The third month: I started clearing inventory, keeping only what was genuinely helping me work, and uninstalled the rest.

This article is the bill after clearing inventory.

It's not a recommendation list; it's an elimination round—writing about which ones stayed, and more importantly, why the others were kicked out.

What is a Skill, and what friction does it solve?

Before getting into the list, there's a perspective worth clarifying first: A Skill is not a better prompt; it's a workflow module with stage gates.

A prompt-level instruction is a suggestion—Claude can reference it or ignore it. A well-structured Skill, if it defines clear stage gates inside ("the red-light test must fail before proceeding to the next step," "a plan must be output as a Markdown file before coding can begin"), Claude is more inclined to follow it.

This difference is real, not a conceptual game.

But this also means: Skill quality is uneven. Among 150+ Skills, some are built to showcase possibilities, and some solve real engineering pain points. After installing 50, I found the latter group accounts for roughly one-third.

The standard I use to decide whether to keep a Skill is: Without it, how much extra time would this task cost me? If the answer is "under 5 minutes," it's probably a gimmick. If the answer is "I have to handle this manually every time, and it's annoying," it's worth installing.

In terms of installation command format, most use npx skills add, a few require git clone into the ~/.claude/skills/ directory, and officially maintained ones use the /plugin install path.

Figure: The essential difference in execution between a Skill's stage-gate mechanism vs. a Prompt's suggestive execution.

Category 1: Engineering Efficiency (6)

These are the ones with the highest frequency in daily coding, and the most justified to keep.

Superpowers (obra/superpowers, 213,000★)

The project with the highest star count in this ecosystem. The name is a bit grand, but the content is real. It's not a single Skill; it's a workflow framework containing 20+ sub-modules: TDD, systematic debugging, plan writing, code review, parallel agent dispatching, Git Worktree management... each is an independent, individually triggerable Skill.

Installation command: npx skills add obra/superpowers

The sub-modules I actually kept are: test-driven-development (enforces red-light first, no skipping), systematic-debugging (reason about the root cause first, then change code), writing-plans (for multi-step tasks, output a file first, then act). The remaining modules are used on demand, not enforced.

Why 213K stars? Because it genuinely solves Claude's most common problem: directly jumping in to change code, without thinking, without testing, changing first and talking later. Superpowers uses structure to forcibly break this bad habit.

Karpathy Guidelines (forrestchang/andrej-karpathy-skills, 125,436★)

AI coding rules summarized by Andrej Karpathy, organized into a Skill. Four core rules: think before reading code (don't just start grepping), be precise with modifications (not "rewrite this file"), prioritize simplicity (not "add features"), and always check against the original requirements.

Installation: /install forrestchang/andrej-karpathy-skills

This Skill's value lies in changing Claude's behavioral pattern, not providing a specific tool. It's particularly effective when starting a new project—Claude will be more inclined to understand first, then act, rather than confidently starting a refactor immediately.

gstack (garrytan/gstack, 93,947★)

A Skill maintained by Garry Tan (YC CEO). The name comes from "Gut Stack"—the tech stack configuration he actually uses. It mainly covers full-stack project scaffolding (TypeScript, React, Supabase, Vercel), best practice checks, and deployment process automation.

Installation: git clone https://github.com/garrytan/gstack.git ~/.claude/skills/gstack

Frankly, I don't use all its features, but I turned on its TypeScript type checking and Supabase Schema validation—every time I create a new interface or change a table structure, Claude proactively runs a check before committing. This reduces low-level errors during my code reviews.

Frontend Design (anthropics/skills, 277,000+ weekly installs)

An officially maintained frontend UI Skill, aiming to solve a real problem: AI-generated UIs all look the same, instantly recognizable as AI-written—button colors, spacing, font choices are all defaults plus Tailwind.

Installation: npx skills add https://github.com/anthropics/skills --skill frontend-design

Its core is providing a visual decision-making framework, so when generating UI, Claude actively picks contrasting colors, considers hierarchical relationships, and avoids excessive symmetry. I felt this most clearly when building internal tools—for the same requirements, the result after installing the Skill was noticeably more "like a human designed it."

Document Skills (anthropics, DOCX/PDF/PPTX/XLSX suite, 132,393★)

An official document generation suite; one installation handles four formats. Core value: lets Claude directly output formatted binary files, instead of outputting Markdown that you then have to convert yourself.

Installation: npx skills add https://github.com/anthropics/skills --skill pdf (similar for other formats)

This Skill's applicable scenarios are narrow but solid: engineers who need to frequently generate reports, internal documents, or data exports. If you only write code every day, you might not use it; if you write technical documentation or send reports to non-technical people, it saves a lot of time.

Trail of Bits Security (trailofbits/skills)

Trail of Bits is a top-tier security audit firm in the industry. This Skill packages their security review checklist. It proactively checks code for injection attack paths, privilege escalation risks, cryptographic implementation errors, etc.

Installation: npx skills add trailofbits/skills

I kept this Skill for interface-layer code reviews. Before, Claude's default code suggestions wouldn't proactively mention security issues. After installing, when encountering code that handles user input, it supplements prompts about possible SQLi or CSRF paths. It's not that Claude becomes a security expert, but at least there's an extra layer of warning.

Category 2: Multi-Agent Orchestration (5)

This category is the fastest-growing direction in the 2026 ecosystem, and also where the most gimmicks are. The multi-agent narrative is compelling, but very few can actually land in daily engineering work.

TDD (superpowers sub-module, 186,724★)

Singled out because it's the part of Superpowers I use most frequently. The core mechanism is three enforced phases: Red (must write a failing test first) → Green (write the minimum code to pass the test) → Refactor (then tidy up). There are clear verification points between each phase; Claude cannot skip them.

This isn't new; everyone knows TDD. But without constraints, Claude naturally tends to write implementation code directly, leaving tests until the end or not writing them at all. This Skill locks down the process.

Ruflo (ruvnet, 49,143★)

A Skill integration for the Ruflo multi-agent orchestration platform, allowing you to design agent pipelines within Claude Code—one agent responsible for research, one for writing code, one for verification, with results passed down the chain.

Installation requires setting up the Ruflo service first: npx create-ruflo-app my-project

Frankly, I uninstalled it after two weeks. The reason: the complexity of most of my projects simply doesn't need a multi-agent pipeline. Ruflo solves the problem of large-scale AI workflows with 100+ steps. If you're doing ordinary business development, it adds more engineering complexity than the time it saves.

It's not a gimmick; it solves a real problem—just not my problem.

Superpowers: Dispatching Parallel Agents (superpowers sub-module)

Multiple independent sub-tasks run truly in parallel, one agent per task; the whole thing finishes when the slowest one completes. This is useful in large refactors: frontend rework, backend interface updates, and test completion can run simultaneously.

I used it during a cross-module refactor and saved about 40% waiting time. But the prerequisite is that tasks are truly independent; if there are dependencies, parallelism becomes serial and error-prone.

Awesome Claude Code Subagents (19,580★)

A community-maintained library of sub-agent recipes, containing various preset "specialized agents"—database agent, document agent, test agent... The idea is good, but execution quality is uneven.

I installed it but only used the database agent; for the others, I wrote my own versions that better fit project constraints. This type of Skill is more of a template library than a plug-and-play tool, suitable for teams with customization needs, not for direct use out of the box.

Loki Mode (loki-mode)

An autonomous system composed of 37 AI Agents, claiming to be able to "completely autonomously complete complex engineering tasks."

I installed it and uninstalled it three days later. Not because it couldn't run, but because it was too autonomous—modifying files I didn't intend to change, committing code without confirmation, refactoring a running function into a "better version." It might be very useful in a sandbox environment, but I wouldn't dare unleash it in a production codebase.

I'll keep an impression of it and wait for it to mature further.

Category 3: Memory & Context (4)

The context window is Claude Code's real bottleneck. This category of Skills solves a specific problem: how to make Claude remember more project knowledge.

Claude Mem (74,903★)

This star count is reliable, and this Skill is reliable too. Core function: automatically extract important decisions, constraints, and architectural choices that appear in each session, store them in a structured memory file, and automatically load the relevant parts in the next session.

Installation: npx skills add claude-mem/claude-mem

Measured effect: In a 3-month project, it saved me the time of re-explaining "why this field was designed this way" every time I started a new session. It's not perfect; there's noise memory, but overall it's worth it.

Claude Context (10,955★)

Lighter weight than Claude Mem, doing only one thing: compressing the current project's core context (CLAUDE.md + key decision files) into the minimum token amount and injecting it at the start of each conversation.

Context bloat as conversation turns increase is a real problem. This Skill helps you find a balance between precision and token consumption.

ccstatusline (9,031★)

Doesn't change Claude's behavior, just gives you a terminal status bar showing how many tokens the current session has used, roughly how much budget is left, and whether a tool call is running.

Sounds like a small tool, but when you start paying attention to costs, this visual information is very valuable. After integrating it, I began to realize which parts of conversations concentrated the token consumption.

CC Switch (67,412★)

A Skill for switching between different Claude models. Core value is cost management: simple tasks go to Haiku (cheap), complex reasoning goes to Opus (strong but expensive), code generation goes to Sonnet (balanced).

Installation: npx skills add cc-switch/cc-switch

This Skill's practicality lies in making model switching a conscious action, rather than defaulting to the strongest one every time. After I started using it, my monthly bill dropped by about 35%, while the completion quality for most tasks didn't noticeably decrease.

Category 4: Documentation & Office (3)

This category of Skills has low visibility in pure engineering circles, but a few are actually very practical.

Graphify (safishamsi, 46,746★)

Automatically generates relationship diagrams from a codebase: function call graphs, module dependency graphs, data flow diagrams. Especially useful for taking over a new project, doing architecture reviews, or understanding legacy code.

Installation: pip install graphifyy && graphify install

The first time I used it was when taking over a Python service that had been running for two years. Graphify drew the module dependency relationships for me in 3 minutes, faster than an afternoon of reading code myself.

Planning with Files (20,925★)

Before starting a multi-step task, makes Claude first output the plan as a Markdown file, clarifying the goal, dependencies, and verification criteria for each step, then begin execution.

Core value: The plan becomes a file that can be checked, modified, and traced, rather than a pile of text existing only in Claude's context. If a task fails, you can look at the plan and find where the deviation occurred.

Claudian (Obsidian plugin, 10,954★)

A Skill that connects Claude Code with an Obsidian note library, allowing Claude to read and write your knowledge base files.

This is useful for engineers who write technical documentation and maintain design docs; for most pure coding roles, the perceived benefit might be low. I installed it, mainly to generate and update ADR (Architecture Decision Record) files.

Figure: A Skill list organized into four categories—Engineering Efficiency, Multi-Agent Orchestration, Memory & Context, and Documentation & Office—including star counts from awesome-skills.com.

What problems did the ones that didn't stay have?

Having talked so much about what stayed, let me briefly mention a few categories that were kicked out. This part might be more useful than the list of what stayed—because it helps you filter out most time-wasting choices before installing.

Too narrow functionality, too specific scenarios: For example, there was a Skill specifically for generating comments for Kubernetes Helm Charts. The functionality was fine, the logic was clear, but our project doesn't use K8s, so installing it was pointless. The problem with this type of Skill isn't poor quality, but too narrow an audience. Before installing, think clearly: How many times a week does the scenario this Skill serves appear in your daily work? If less than once, consider not installing.

Complex installation, too low return: Some Skills require setting up a local service, configuring API Keys, setting Webhooks. After going through a five-step installation process, what you get in return is "Claude adds an emoji at the end of the reply." A mismatch between installation cost and usage benefit is a common flaw of many community Skills. A good Skill should be "one command line to install, and you can feel the difference the next day"—if a week after installing you're still not sure if it's taking effect, you won't lose anything by uninstalling.

Excessive autonomy, blurred boundaries: This type is the most dangerous. The Skill description says "Claude will handle it automatically," but in reality, Claude makes autonomous decisions to modify code without your awareness. Loki Mode is a typical example. In the three days I had it installed, it "optimized" a core function that was running, committed the code, and then told me "Completed." In a sandbox environment or test project, this is completely fine, but in a production codebase, this autonomy is a risk, not an advantage. Judging standard: Does this Skill ask you "Do you want to continue?" before key operations? Be cautious with Skills that lack a confirmation mechanism in a production codebase.

Pure prompt wrapping, no structure: This is the most common type. A batch of Skills essentially just wraps a piece of prompt into a SKILL.md format, with no stage gates, no verification mechanism, no input/output constraints. Claude is very likely to ignore it—or use it on the first trigger and then never again. This type of Skill has the best-written READMEs, looking powerful in features, but the effect when used is almost the same as not having it installed. Identification method: Open the SKILL.md. If the entire text is descriptive and lacks any structure like "Step N: Verify X passes before proceeding," it's highly likely pure prompt wrapping.

Figure: A 5-step filtering decision framework—from usage frequency to a one-week real-world test, systematically judging whether to keep or uninstall a Skill.

FAQ

Q: Will Claude definitely use a Skill once it's installed?

Not necessarily. Skill loading is based on relevance assessment; Claude evaluates whether the current task matches the Skill's description. You can manually trigger it with /skill-name, or bring out the Skill's keywords in the task description. If you find it installed but unused, first check whether the trigger description in SKILL.md is specific enough.

Q: Do these Skills affect Claude's token consumption?

Skill files are lazily loaded; they won't load for irrelevant tasks, so in most cases, the cost impact is minimal. But if you install a large number of Skills that auto-trigger in every conversation, the accumulation can have an impact. Skills specifically for managing costs, like CC Switch, can help you see this clearly.

Q: Can multiple Skills conflict with each other?

Yes, but it's not common. The most common conflict is when two Skills have trigger descriptions that are too similar, and Claude isn't sure which one to use. Solution: Add priority markers to interrelated Skills (write priority: high in the frontmatter), or streamline the trigger descriptions.

Q: How do I know if a Skill is worth installing?

Look at three indicators: star count (a reference, not a deciding factor), whether the README has a clear "trigger condition" description (Skills with vague descriptions are usually also executed vaguely by Claude), and whether there's a maintainer continuously updating it on GitHub. A Skill that hasn't been updated in six months might already be incompatible with the latest version of Claude Code.

Q: Is there a Skill discovery directory so I don't have to browse GitHub one by one?

awesome-skills.com is currently the most comprehensive directory, sorted by star count, with installation commands. The awesome-claude-skills repository maintained by travisvn is also worth looking at, focusing on quality filtering rather than quantity.

References

Installing Skills is a bit like hiring—the one with the flashy resume isn't necessarily good; the one who doesn't talk much but delivers every time they speak is the real productivity.

These 20 that stayed aren't the ones with the most stars; they are the ones that genuinely reduced friction in my actual workflow. Your situation might be different, but the filtering logic should be similar: After installing, is there something you previously had to do manually that Claude now proactively does for you? If yes, keep it. If no, uninstall.

After writing this, MageByte also went through the skills directory again and found two more that could be cleaned up. If you have a colleague who is struggling with whether to install Skills, sending them this article directly is much faster than having them browse awesome-skills.com themselves. Next, I plan to talk about Claude Code's Hooks mechanism—used in conjunction with Skills, it can truly lock down your workflow. Stay tuned if you're interested.