I Tested 28 Claude Code Skills — Here Are the 5 I Kept

I Tested 28 Claude Code Skills — Here Are the 5 I Kept

After trying 28 Claude Code skills in real work, one developer kept only five: ponytail, caveman, graphify, grill-me, and ui-ux-pro-max. The filtering process itself is more valuable than the list.

The core reasoning is straightforward: every installed skill consumes context window, and large models are rapidly absorbing capabilities that once required external frameworks. Six months ago, complete development methodology frameworks like Superpowers and Get Shit Done were the fastest path to teaching coding agents how to plan, test, and review; today, much of that behavior is built into the models. The author's sole criterion for evaluating each skill was: Do the tokens it loads justify the change in outcomes it delivers?

5 Skills Worth Keeping

ponytail: Make Agents Write the Minimum Working Code

ponytail (MIT license) pushes agents to accomplish work with the least amount of code. According to its README, since version 5 it has reported roughly 53% less code, 26% lower cost, and 41% faster execution — though these are the author's own benchmark figures, not third-party verified.

This skill addresses the widespread LLM tendency toward "over-generation" — models lean toward writing more code to demonstrate capability, while ponytail intervenes via a hook mechanism at three points: SessionStart, SubagentStart, and UserPromptSubmit, pulling output back to "good enough." The install command is /plugin marketplace add DietrichGebert/ponytail, followed by /plugin install ponytail@ponytail.

Note that it operates through automatically running hooks. When installing in Codex, you need to trust its two lifecycle hooks before it takes effect.

The hook mechanism is key to understanding ponytail and the security warnings below. In agents like Claude Code, hooks are scripts bound to specific lifecycle events that execute automatically: SessionStart fires when a session is established, SubagentStart fires when a spawned subagent launches, and UserPromptSubmit fires after each user prompt submission but before the model generates a response. The defining trait of hooks is that they run automatically without model judgment, so they can rewrite prompts before they reach the model (ponytail uses this to compress "write more" instructions into "just enough"), but it also means scripts execute silently with user permissions — which is precisely why the original article emphasizes "check hooks before installing."

caveman: Say It Clearly With Fewer Tokens

caveman (Apache-2.0 license) makes agents express themselves in concise, restrained English while maintaining code precision. An optional local proxy can also compress content the agent reads, such as logs, JSON, and test output. According to its README, across 54 Claude Code runs, input tokens dropped by 33.2%.

Two privacy facts are worth noting: the proxy runs on the local machine, sitting between the agent and the model API, using your own keys; the standalone caveman CLI sends usage statistics by default — commands, token counts, a random install ID, OS, and IP — but never prompts or code. You can disable this with caveman telemetry off or by setting DO_NOT_TRACK=1. The skill itself sends no data.

graphify: Turn Your Codebase Into a Queryable Knowledge Graph

graphify (Apache-2.0 license) transforms codebases, documentation, SQL schemas, and PDFs into a queryable knowledge graph, outputting graph.html, GRAPH_REPORT.md, and graph.json, queried via the /graphify command. Code is parsed locally with tree-sitter and never leaves your machine; documents and media are processed through your configured model or API key.

Its value lies in freeing agents from having to re-understand the structure of large codebases on every task. However, the project currently has around 1,500 open issues, and the README points to the paid graphify.com platform — its maintenance pace is worth monitoring.

grill-me: Relentless Cross-Examination of Your Approach

grill-me belongs to Matt Pocock's skill collection (MIT license) and performs a "relentless interview of a plan or design." It hands the task to a questioning skill that poses sharp questions in rounds, each accompanied by recommended answers you can accept or override.

This skill sets disable-model-invocation: true, so it doesn't load automatically — it only runs when you explicitly invoke it. This means zero daily overhead on your context window, yet it provides structured stress-testing at critical decision points. This "load on demand" model is exactly the design philosophy the author believes skills should follow.

Install via /plugin install mattpocock-skills; it has made it into the official Claude Code marketplace.

ui-ux-pro-max: Design Assistance That Understands Patterns

ui-ux-pro-max (MIT license) adds design intelligence for cross-platform interface building. Version 2.0 introduces a design system generator that can suggest patterns, color schemes, and call-to-action placement for projects.

For developers who need to quickly produce usable interfaces, this skill fills the gap in general coding models' design decision-making. The install command is /plugin marketplace add nextlevelbuilder/ui-ux-pro-max-skill, followed by /plugin install ui-ux-pro-max@ui-ux-pro-max-skill.

The 23 Skills Removed, and the Framework Behind the Decision

Two big names appear among the removed: Superpowers and Get Shit Done (now continuing as GSD Core). Both are excellent frameworks — Superpowers is a complete development methodology built on composable skills, and GSD is a meta-prompting and spec-driven development system. Six months ago they let agents plan, test, and review in ways they couldn't on their own, and the author used both at the time.

The change came from the models themselves. Much of what these frameworks do is now built in. Moreover, loading a complete methodology into every session directly conflicts with the principle of "loading only the few skills that change outcomes." Most of the other removed skills fall into the same category: things models now do by default, or things the author can describe clearly with two lines of project instructions.

This decision framework can be distilled into three questions:

• Does the model already do this by default now?
• Can I replace it with brief project instructions?
• Is the change in outcomes it delivers worth loading it every session?

The context window is the core cost variable throughout this article. It's the total amount of tokens a model can simultaneously "see" in a single inference — including system prompts, skill descriptions, conversation history, read-in files, and tool outputs, all sharing the same quota. This means skills are not "free plugins": every resident skill's SKILL.md and its description occupy a fixed chunk of tokens in every session, and the space squeezed out directly reduces capacity available for the code itself — while also diluting the model's attention on what truly matters. This is why the author uses "do the tokens justify the change in outcomes" as the sole filtering criterion, and also explains why grill-me's on-demand loading (disable-model-invocation: true) earned special praise.

Skill Compatibility With Codex

Most skills work across tools. Skills follow the open Agent Skills standard: a folder containing a SKILL.md file and optional scripts. Codex reads skills from .agents/skills in the repo and ~/.agents/skills in the user directory, invoked with $skill-name.

Plugins are tool-specific because they can bundle hooks and commands, so you'll need to look up each project's Codex installation method. All five skills mentioned above currently have Codex installation paths.

The Agent Skills standard is an open convention proposed by Anthropic in 2025 for reusing the same skill definition across different agent products. Its smallest unit is a folder where SKILL.md declares metadata via YAML frontmatter (such as name, description, and whether the model may invoke it automatically), followed by any scripts, templates, or reference documents. The standard is deliberately minimal, specifying only "how to describe a process" without dictating how the host executes it, so Claude Code, Codex, and even third-party tools can read the same directory. A plugin is a higher-level packaging unit that, beyond skills, can bundle hooks, slash commands, and marketplace source information. Once hooks are involved, it becomes tightly bound to the host's event model, and cross-tool reusability drops accordingly.

Is It Safe to Install Skills?

Skills are instructions plus optional scripts that run with your permissions. Before installing, consider:

• Read the SKILL.md. It's short and tells you exactly what the skill asks the model to do.
• Check the hooks. Hooks run automatically on event triggers without prompting. ponytail's Codex plugin requires you to trust two hooks.
• Check telemetry and network calls. The caveman CLI is a positive example — it clearly states what it sends and how to stop it.
• Prioritize projects with clear licenses and active maintenance. All the skills mentioned above are MIT or Apache-2.0 licensed and were actively maintained when the author checked.

Telemetry and vendor neutrality are two dimensions easily overlooked here. Telemetry refers to usage data tools report in the background, and its scope can vary widely: caveman's standalone CLI reports command names, token counts, a random install ID, OS, and IP, but explicitly excludes prompts and code — a relatively restrained approach that offers two opt-out switches in caveman telemetry off and DO_NOT_TRACK=1. To judge whether a skill is safe, beyond the points listed in the original article, also consider: whether scripts make external network requests, whether they read ~/.ssh or secrets in environment variables, and whether dependencies are version-pinned. Any skill demanding unrelated permissions in the name of "convenience" should be audited before installation.

FAQ

What are the best Claude Code skills? After testing 28, the five kept are: ponytail for writing less code, caveman for more concise output, graphify for codebase knowledge graphs, grill-me for stress-testing plans, and ui-ux-pro-max for interface design. The best set should be small, because every installed skill competes for context.

Do Claude Code skills work in Codex? Mostly yes. Skills follow the open Agent Skills standard, and Codex reads from .agents/skills. Plugins that bundle hooks or commands are tool-specific.

What's the difference between skills and MCP servers? Skills teach Claude a process, like how to review code or plan a feature; MCP servers give Claude access to another system, like GitHub or a database. Skills change what Claude knows; MCP servers change what it can reach. Many workflows use both.

Fewer Skills, Better Results

Models will keep absorbing the capabilities skills add today, and this list will keep shrinking. The truly durable habit is the question behind it all: Is this skill's change in outcomes enough to earn a place in every session?

If you could keep only one skill, which would you choose?

---

This article is compiled and adapted from a hands-on article published on nulltensor.com.