DEV Community: Skillselion

Claude Code talks too much. 375,000 installs say developers agree.

Skillselion — Thu, 23 Jul 2026 07:51:38 +0000

The fastest way to burn a Claude Code usage limit is not a hard problem. It is the agent narrating a plan, restating your context, explaining the diff it is about to write, writing it, then summarizing what it just did. Multiply that by every task in a session and the meter runs out while the actual work was maybe a quarter of the tokens.

Developers have started fixing this with skills, and the install numbers show it has quietly become its own category. Three of the risers on our trending rail this week are not capability skills at all. They are muzzle skills: their whole job is to make the agent produce less.

The numbers

caveman (GitHub) - 374,542 installs, 92,125 stars, search interest up 110% over the last 30 days. It compresses agent output across replies, commits, and reviews, claiming roughly a 75% token cut while keeping every technical detail. The pitch line that lands: answers that read like a senior engineer's Slack message, not a tutorial.

ponytail (GitHub) - 19,421 installs, 87,947 stars, and the sharpest momentum of the three: search interest for "ponytail github" is up 750%. It is a "lazy senior developer" skill that forces the simplest possible solution through a seven-rung decision ladder (do we need this? does it exist? is it in the stdlib?) before any code gets written. Less output here means fewer speculative features and smaller diffs, not just shorter prose.

stop-slop (GitHub) - 7,969 installs, 14,269 stars, search interest up 130%. Narrower target: the recognizable AI prose patterns themselves. Where caveman compresses everything, stop-slop rewrites the tics.

All three numbers come from our live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

Why this category exists now

Two weeks ago the risers were taste skills: design-judgment layers like ui-ux-pro-max (now past 280,000 installs) that constrain what the agent builds. The token-diet skills are the same move one level down. Developers are not asking their agents for more capability. The models are capable enough. They are asking for less output per unit of work, because output is what they pay for, wait for, and have to read.

There is a real cost argument (a 75% token cut on a metered plan is not cosmetic) but I think the stronger driver is review fatigue. Every sentence the agent writes is something you have to at least skim. Verbose agents shift work from the model to you. A skill that deletes the narration deletes that review load with it.

One sentence to take away: the highest-leverage Claude Code skill right now might be the one that makes it do less, and 374,000 caveman installs suggest that is not a niche opinion.

If you want to watch this category move, the trending skills rail updates from live Google search data, and the Code Review & Quality category is where most of these land.

I work on Skillselion, a directory of Claude Code, Codex and Cursor extensions ranked by real installs.

The two fastest-growing Claude Code skill searches right now are both taste layers

Skillselion — Wed, 22 Jul 2026 07:53:38 +0000

Your agent just shipped a working dashboard. It compiles, the tests pass, and it looks exactly like every other AI-generated UI on the internet. Same card grid. Same almost-right spacing.

The model writes correct code all day. What it will not do, unprompted, is care how the result looks.

Developers have apparently noticed. On Skillselion's trending rail, which tracks rising skill searches against a live catalog of 59,000+ skills ranked by real installs, the top two risers this week are both breakout terms, and both of them are taste layers:

Ui Ux Pro Max (GitHub) - 275k installs. Instant UI/UX decisions, component recommendations, style guidance.
Design Taste Frontend (GitHub) - 271k installs. Its own pitch: "override generic LLM frontend output with intentional, metric-driven UI/UX taste."

Neither one gives the agent a new capability. They exist to strip away defaults.

Five risers, one pattern

Look further down the same rail and the pattern holds:

Ponytail (GitHub), +750%: force the simplest, shortest solution, eliminate unnecessary code and dependencies.
Stop Slop (GitHub), +130%: strip predictable AI patterns from prose.
Caveman (GitHub), +110% and 364k installs: cut token usage ~75% without losing technical detail.

All five risers do the same job: restraint. In pixels, in code, in prose, in tokens.

There is a second thing happening that makes this more than a curiosity. The New Stack recently argued that Cursor, Claude Code and Codex are converging into one composable stack: orchestration, execution, review, mix and match. If the agents are interchangeable, the model is no longer where your output gets its character. The constraint layer is, and unlike the model's defaults, it travels with you from agent to agent.

Two things worth acting on

Treat taste as a dependency, not a vibe. A taste skill is a reviewable rules file: spacing scales, type ramps, what never to generate. You can diff it, version it, and argue with it in a PR. That beats re-prompting "make it look less generic" forty times per project, and it is why the top riser sits at 275k installs: people got tired of writing prompt number forty-one.

Watch installs, not stars. The #1 riser has 108k stars and 275k installs. Stars measure applause. Installs measure need. When the skills whose whole job is saying no outrun everything else in a 59,000+ skill catalog, that is the market telling you what is actually scarce: judgment.

The trending rail refreshes daily at skillselion.com. If you want your agent to pull the right skill mid-task instead of shopping first, there is an MCP server for that: skillselion-mcp.

I work on Skillselion, the directory of Claude Code, Codex and Cursor extensions ranked by real installs. Data above is from the live catalog, refreshed daily from skills.sh, GitHub and MCP registries.

The fastest-rising Claude Code skill searches this week are about restraint, not power (July 20 data)

Skillselion — Mon, 20 Jul 2026 08:01:05 +0000

Yesterday I watched an agent take a one-line bug report and produce a 400-line pull request. New abstraction layer, two helper modules, a config option nobody asked for. The fix itself was four lines, buried somewhere in the middle.

That experience is apparently common enough to show up in search data.

The seven fastest-rising Claude Code skill searches this week are all skills that constrain agent output - less code, fewer tokens, better design judgment - not skills that add capability.

Google Trends (past-month window, worldwide, July 20) shows seven "claude code skills" searches rising fast. Here they are, with live install counts:

Rising search	Trend	What it does	Installs
ui-ux-pro-max-skill	Breakout	design system for agent UI output	275,112
taste skill	Breakout	metric-driven design taste for frontend work	271,494
ponytail github	+750%	forces the simplest, most minimal solution	17,617
stop slop skill	+130%	strips AI writing patterns from prose	7,686
caveman skill	+110%	claims ~75% token savings without losing technical detail	364,180
impeccable github	+110%	design polish pass for shipped UIs	199,134
front end design skill claude code	+90%	Anthropic's own frontend design skill	682,858

Install counts come from the live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

Two camps, one complaint

Look at what these seven actually do. Four of them (ui-ux-pro-max, taste, impeccable, frontend-design) are design judgment skills: they exist because agent-generated UIs are functional but generic. The other three (ponytail, caveman, stop-slop) are restraint skills: less code, fewer tokens, less filler prose.

Not one of the seven makes an agent do more.

Earlier waves of agent tooling were about adding capability. This week's risers are all corrective: developers have the capable agent, and now they are searching for the skills that rein it in.

The restraint stack, ranked by installs

If you want to try the "do less" camp, here is the shortlist with real numbers behind it:

caveman (364,180 installs) - its pitch is roughly 75% less context usage without dropping technical detail. The biggest of the three at 20x the next one, which makes sense: token budgets are a bill, not a preference. Catalog page · GitHub
ponytail (17,617 installs) - a standing instruction to pick the simplest possible implementation and delete unnecessary code, dependencies and features. This is the one that would have turned my 400-line PR into four. Catalog page · GitHub
stop-slop (7,686 installs) - removes the recognizable AI writing patterns from any prose your agent produces: docs, commit messages, PR descriptions. Catalog page · GitHub

And the taste camp, for when the output works but looks like every other agent's output:

frontend-design by Anthropic (682,858 installs) - the most-installed skill in this week's risers. Catalog page · GitHub
ui-ux-pro-max (275,112 installs, this week's Breakout) - Catalog page · GitHub
design-taste-frontend (271,494 installs, also Breakout) - Catalog page · GitHub
impeccable (199,134 installs) - Catalog page · GitHub

The install numbers put restraint in the mainstream: caveman alone is past 364,000 installs.

Why this matters if you run agents daily

The default failure mode of a capable coding agent in mid-2026 is too much code, wrapped in too many words, styled the same as everyone else's. The fix turned out to be standing instructions, packaged as skills, that encode judgment instead of capability.

If your agent's PRs read like my 400-line example, start with one skill from each camp: ponytail for the code volume, and whichever design skill matches your stack for the output quality.

The full ranked list, updated daily by real installs, is on Skillselion - the seven above are live on the homepage rail right now.

I run Skillselion, a directory of Claude Code, Codex and Cursor extensions ranked by real installs. The trend labels come from Google Trends (past month, worldwide, captured July 20); install counts are from the live catalog.

Claude Code 2.1.215 Stopped Running /verify Automatically. Here Is the Better Workflow

Skillselion — Sun, 19 Jul 2026 08:32:49 +0000

Claude Code 2.1.215 changed a small behavior with a large operational consequence: /verify and /code-review no longer run automatically. You must invoke them explicitly.

In short, Claude Code now leaves verification invocation to the user, so teams should name, run, and record their checks explicitly.

That is not a reason to trust agent output less. It is a reason to make your team's validation steps explicit.

An implicit check is easy to forget, hard to audit, and difficult to reproduce across tools. An explicit check gives the team a named step, observable evidence, and a clean failure boundary.

Treat verification as a workflow stage

A reliable agent loop has four stages:

Define the exit criteria before implementation.
Let the agent change the smallest useful surface.
Run the relevant checks explicitly.
Review the evidence before accepting the result.

The important word is relevant. A formatting-only change does not need an integration suite. An authentication change should not stop at lint. Match the check to the risk.

Ask hard questions before code exists

A pre-implementation challenge can expose missing constraints before they become patches. Matt Pocock's grill-me skill on Skillselion (GitHub) is one way to turn vague requirements into batches of concrete questions.

Use it to resolve questions such as:

What behavior must remain unchanged?
Which failure states need tests?
What evidence will prove the task is complete?

This is cheaper than discovering the same ambiguity after the implementation has spread across several files.

Keep feedback close to implementation

The test-driven-development skill on Skillselion (GitHub) keeps the feedback loop close to the change: write a failing test, make it pass, then refactor with the suite still green.

TDD is not a substitute for the final verification step. It covers the behavior you chose to specify. The explicit /verify or /code-review pass asks a different question: did the completed change satisfy the repository's broader contract?

Make the evidence part of the handoff

A useful completion note should say more than "tests pass." Record:

the exact checks that ran;
their exit status;
any checks intentionally skipped and why;
residual risks that still need human judgment.

For example:

Verified: unit tests, typecheck, and the focused auth integration suite.
Skipped: full end-to-end suite because this environment has no payment sandbox.
Residual risk: session expiry behavior still needs staging confirmation.

This gives the next reviewer something falsifiable. It also prevents a green statement from hiding a missing check.

CI is still the final shared contract

Local agent verification is fast feedback. CI is the team-visible, repeatable contract. Keep required checks in CI even when an agent ran the same commands locally.

The practical response to Claude Code 2.1.215 is simple: do not recreate hidden automation. Put verification into the task definition, invoke it deliberately, and attach the evidence to the handoff.

That is a stronger workflow than hoping the agent remembered.

Building an explicit validation loop? Browse Skillselion for reusable planning, testing, and code-review skills, then add the checks your repository actually requires.

Source: Claude Code v2.1.215 release notes

Fable 5 lands in every Max plan on July 20, at half limits. The install data shows what developers do about limits

Skillselion — Sat, 18 Jul 2026 08:36:24 +0000

Anthropic posted the announcement at 2 AM UTC and it was everywhere by breakfast: starting July 20, Claude Fable 5 will be "included in all Max and Team Premium plans, at 50% of limits." Pro and Team Standard users stay on usage credits and get a one-time $100 credit. Twelve hours in, the post sits at 32,175 likes and 6.2 million views.

The upside needs no explanation. Fable 5 is the strongest coding model Anthropic ships, and from Sunday it comes with the plan you already pay for. The catch is the second half of the sentence: half limits, for the hungriest model you can point at a repository. The reply threads are already full of developers doing the math on what an agentic loop does to a half-size window.

That math has an answer you can measure in installs. Developers have been voting on it all week.

We ranked this stack 8 days ago. Here is what happened since.

When GPT-5.6 launched on July 9 and developers immediately hit their usage limits, we published a ranking of context-efficiency skills: the tooling that stretches a fixed usage window by cutting wasted tokens. Eight days later, that same stack has added 20,864 installs. The growth is lopsided, and the lopsidedness is the story.

Skill	Jul 10	Jul 18	Change
subagent-driven-development	140,798	149,562	+8,764 (+6%)
improve (shadcn)	20,365	24,497	+4,132 (+20%)
ponytail	12,544	16,937	+4,393 (+35%)
context-engineering	9,762	12,621	+2,859 (+29%)
context-map	9,357	9,406	+49 (0%)
remembering-conversations	8,891	8,974	+83 (+1%)
claude-md-improver	6,960	7,544	+584 (+8%)

To be clear about causality: none of these installs happened because of last night's announcement. They happened because GPT-5.6 taught everyone the same lesson in week one, and the lesson generalizes. Frontier models eat limits. The announcement just extended that lesson to every Max subscriber at once.

Look at where the growth concentrated. The three fastest risers (ponytail +35%, context-engineering +29%, improve +20%) all shape what the model does before it spends tokens: force the minimal solution, curate what the agent sees, produce a plan another agent can execute without extra context. The flat rows (context-map, remembering-conversations) accumulate more context into the session. Developers under limit pressure are choosing fewer, better turns over richer context. That is a preference you can read straight off the install counts.

The limit-stretching stack, re-ranked for July 20

Ranked by installs from the live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs. Every count is from today.

1. subagent-driven-development (149,562 installs) (GitHub)
Executes an implementation plan by dispatching a fresh subagent per task, with diffs and reports kept in files instead of session history. The main context stays small while the work happens elsewhere. On half limits, context isolation is the single biggest lever you control.

2. improve (24,497 installs) (GitHub)
Surveys a codebase like a senior advisor and produces prioritized, self-contained implementation plans that other agents can execute without additional context. Self-contained is the key word: a plan that needs no follow-up questions is a plan that burns no follow-up tokens.

3. ponytail (16,937 installs) (GitHub)
Forces the simplest, shortest, most minimal solution at every step and strips unnecessary code, dependencies and features. The fastest-growing skill on this list, up 35% in eight days. Minimal output is cheap output, and a half-limit window turns every extra generated line into a real cost.

4. context-engineering (12,621 installs) (GitHub)
Addy Osmani's skill for deliberately curating what an agent sees, when it sees it, and how it is structured. The discipline of deciding what enters the window, rather than letting the session accumulate.

5. context-map (9,406 installs) (GitHub)
Generates a precise map of relevant files, dependencies, tests and patterns before any code gets touched. Flat this week, but still the right first move on unfamiliar code: a wrong-file exploration loop is the most expensive way to spend a premium model.

6. remembering-conversations (8,974 installs) (GitHub)
Recalls relevant past sessions when you hit a similar feature or a recurring bug, so you stop re-paying for context the model already had once.

7. claude-md-improver (7,544 installs) (GitHub)
Anthropic's own skill for auditing and improving CLAUDE.md files. Your CLAUDE.md is a fixed tax on every single session; this is the one-time cleanup that lowers it permanently.

8. NEW: strategic-compact (6,172 installs) (GitHub)
The new entrant since our July 10 ranking. Suggests manual context compaction at logical workflow boundaries instead of letting auto-compaction fire mid-task. Compaction timing sounds trivial until an auto-compact wipes the plan your agent was halfway through executing.

Two takeaways

1. Half limits on a stronger model is a trade you win by cutting retries, and the install data shows developers already optimizing for it. Plan-first and minimal-output skills grew 20 to 35% in eight days. Passive context tooling stayed flat. The community is converging on a workflow shape: decide more before the model runs, generate less when it does.

2. On July 20 the usage-limit conversation stops being an edge-case complaint and becomes the default condition of using the best model. Every Max subscriber gets Fable 5, and every Max subscriber gets it at 50% of limits. The developers who treat the window as a budget to engineer get roughly twice the model-hours out of the same subscription.

The full ranked shortlist, updated daily, is on skillselion.com, and the install-ranked leaderboard is at skillselion.com/leaderboard.

Disclosure: I run Skillselion, a directory of Claude Code, Codex and Cursor extensions. Install counts come from our live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

Cursor can now code across Slack channels and repos. The hard part is agent coordination

Skillselion — Sat, 18 Jul 2026 08:32:10 +0000

On July 17, Cursor added plan-first Slack replies, named multi-repository environments, and the ability for its agent to read and post across channels. Once a coding agent can start from Slack, coordination becomes the risk surface: repository selection, context, verification, and inspectable evidence.

A safe Slack-to-code workflow needs six controls: planning, task independence, fresh context, verification, root-cause debugging, and review.

Cursor's primary changelog describes three useful changes:

The agent can propose a plan in Slack before execution.
Teams can name environments that contain multiple repositories.
Agents can read from and post to multiple channels during a task.

Those are coordination primitives. They do not decide how your agent should plan, split work, verify claims, or request review. That policy belongs in the skills and instructions you attach to the workflow.

I checked the live Skillselion catalog on July 18, 2026. These six operational skills from the same open-source collection follow workflow order, not install rank.

1. Start with `writing-plans`

writing-plans had 188,754 catalog installs on July 18, 2026.

It turns a high-level specification into an executable plan with file mappings, small tasks, tests, and documentation references. The source is available on GitHub.

This is the best first gate for a Slack-launched agent. Ask it to post the plan before it edits anything. A reviewer can catch a wrong repository, missing migration, or unsafe deployment assumption while the cost of correction is still low.

2. Parallelize only independent work

dispatching-parallel-agents had 138,691 catalog installs on July 18, 2026.

It dispatches independent tasks concurrently with isolated context. Its implementation is on GitHub.

Multi-repo access makes parallel work tempting. Independence is the constraint that matters. Two agents editing the same contract, migration, or shared type are not parallel tasks. They are a merge conflict with a longer explanation.

3. Give every subtask a fresh owner and two review stages

subagent-driven-development had 149,562 catalog installs on July 18, 2026.

It executes a plan with a fresh subagent per independent task and automated specification and quality review. The source is on GitHub.

Fresh context reduces accidental carry-over. The two review stages separate "did we build what the plan asked for?" from "is the implementation good enough?" That distinction is especially useful when Slack compresses a long task into a few status messages.

4. Make completion an evidence claim

verification-before-completion had 148,104 catalog installs on July 18, 2026.

It requires fresh command output before an agent says a task is complete. The source is on GitHub.

A green Slack reply is not a test result. A useful completion message names the commands run, their exit status, the affected repository and commit, and any test or deployment that was intentionally skipped.

5. Escalate failed verification into debugging

systematic-debugging had 191,037 catalog installs on July 18, 2026.

It forces root-cause discovery before code changes through a four-phase debugging process. The source is on GitHub.

This keeps a failed check from turning into a sequence of speculative edits across repositories. In a cross-channel workflow, post the failure evidence where the task started, then keep the detailed diagnosis in one thread.

6. Request review with a fixed contract

requesting-code-review had 171,122 catalog installs on July 18, 2026.

It dispatches a consistent reviewer that checks plan deviations and implementation quality. The source is on GitHub.

The reviewer should receive the plan, exact diff range, test evidence, and known limitations. "Please review" is not enough context for a human or an agent.

A practical Slack-to-code contract

Before you let a channel mention start a multi-repo coding task, define this contract:

Identity: Which user, bot, and repository permissions authorized the work?
Scope: Which repositories and directories may change?
Plan: Where is the proposed plan, and who can approve it?
Concurrency: Which tasks are truly independent?
Evidence: Which tests, builds, and deploy checks prove completion?
Provenance: Which commits, pull requests, and environments changed?
Rollback: How will the team stop or revert the task?

Cursor's Slack improvements lower the cost of invoking an agent. The operational advantage comes from pairing easy invocation with hard boundaries and inspectable evidence.

The chat thread is becoming a control plane for code changes. It needs policy, state, verification, and audit trails.

Compare the six skill pages and review their source before installing anything.

Skillselion is an independent directory, not affiliated with Anthropic, OpenAI, or Cursor. The live catalog is refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

Claude Code's changelog now reads like a security bulletin. The skills developers install don't.

Skillselion — Fri, 17 Jul 2026 07:57:55 +0000

Open the Claude Code changelog from this week and read it the way you would read a CVE feed. Version 2.1.212 fixed plan mode auto-running file-modifying Bash commands like rm without a permission prompt. It fixed worktree creation following a repository-committed symlink that could create files outside the repository. One release earlier, 2.1.211 fixed permission previews relayed to chat channels, so that bidirectional-override characters, zero-width characters, and look-alike quotes inside tool inputs can no longer visually alter the approval message you see there.

That last one deserves a second read. Until this fix, a malicious tool input could dress itself up to look safe in the very approval preview a reviewer was reading in chat.

None of this is a knock on Anthropic. Shipping fixes this specific, in public, weekly, is what a serious vendor does. The point is what it tells us: the attack surface of AI-assisted development has moved from the code you write to the agent that writes it. Prompt injection, permission-preview spoofing, sandbox escapes, malicious skills. This is where the incidents are now.

So here is the uncomfortable part. We run Skillselion, a directory of Claude Code, Codex and Cursor extensions ranked by real installs (live catalog, refreshed daily from skills.sh, GitHub and MCP registries). When you look at what developers actually install under "security", the picture is a decade out of date.

Agent security vs code security: what the install numbers say

The heavyweights are all code-security skills, tools that audit the software you ship:

firebase-security-rules-auditor by Firebase (GitHub): 71,873 installs
golang-security (GitHub): 34,000 installs
better-auth-security-best-practices (GitHub): 20,323 installs
security-review by Sentry (GitHub): 10,629 installs

Now the skills that secure the agent itself, the layer the changelog keeps patching:

skill-vetter (GitHub), which audits a skill before you install it: 20,395 installs
claude-settings-audit by Sentry (GitHub), which audits your Claude Code settings: 3,138 installs
seatbelt-sandboxer by Trail of Bits (GitHub), which confines agent processes on macOS: 3,085 installs
prompt-injection-scanner (GitHub): 222 installs

A Firebase rules auditor has 323 times the installs of a prompt injection scanner. Trail of Bits, one of the most respected security shops in the industry, publishes a sandboxing skill for the class of problem the changelog keeps fixing, and it sits at 3,085 installs while a Go code-security skill clears 34,000.

Takeaway 1: the attack surface moved to the agent, but install behavior hasn't caught up. Developers are still buying locks for the front door while the new entrance is the agent that holds the keys to the whole house: your shell, your filesystem, your credentials, your CI.

Skills are dependencies. Almost nobody audits them.

There are more than 61,000 skills in the catalog right now. A skill is a markdown file plus bundled scripts that you hand to an agent with Bash access. Functionally, that is an npm package with fewer guardrails: no lockfile by default, no signature, and an execution context that includes your entire dev environment.

We have been here before. npm hit this moment a decade ago, and the ecosystem answered with npm audit, lockfiles, provenance, and supply-chain scanners. The agent-skill ecosystem is at the pre-audit stage of that curve, except this time the package runs with your shell, your credentials, and your repos already in scope.

The interesting signal in the data is skill-vetter at 20,395 installs. It is the one agent-security skill with real traction, and what it does is exactly the dependency-audit reflex, ported to skills: inspect what a skill actually does before it runs. That reflex spreading is what maturity will look like.

Takeaway 2: vetting a skill before installing it is the new dependency audit. In two years, installing an unvetted skill with Bash access will look the way curl | sudo bash looks today.

How to audit your agent layer

Three habits. None of them need a framework:

Read the changelog of your agent the way you read security advisories for your runtime. It is one of the highest-signal security feeds in AI-assisted development right now, and it is free.
Audit the agent layer, not just the code layer. Your permission allow-lists, your installed skills and MCP servers, and your sandbox settings are production config now.
Before installing a skill, look at what it bundles and what it can touch. Install counts and the file tree are public on every Skillselion listing, and the skillselion-mcp server lets your agent check a skill's footprint before it installs anything.

The vendors are doing their part of the job. The install data says most of us have not started ours.

I work on Skillselion, the directory the install numbers above come from. All counts were read from the live catalog on July 17, 2026.

The fastest-rising Claude Code searches this week are names, not tools

Skillselion — Thu, 16 Jul 2026 10:41:19 +0000

Two search terms broke out on Skillselion's trending rail this week. "Andrej Karpathy skills" is up 1,900 percent. "Corey Haines marketing skills" is up 1,600 percent.

Neither one is a tool name. Both are people.

That is a new pattern. For months the breakout searches were capabilities: browser automation, frontend design, token efficiency. This week, developers typed names into the search box. With 60,000+ skills in the catalog, I think that shift was inevitable.

Reputation is becoming the discovery layer for agent tooling.

The Karpathy case: demand without supply

Andrej Karpathy has never published a Claude Code guidelines repo.

Search his name in the catalog and the top results are other people packaging his public advice:

karpathy-guidelines (GitHub): 18,059 installs. Behavioral rules distilled from his observations on LLM coding pitfalls: think before coding, simplicity first, surgical changes that touch only what you must.
karpathy-llm-wiki (GitHub): 5,289 installs. Builds a Karpathy-style LLM wiki as your project's knowledge layer.
andrej-karpathy-perspective (GitHub): 2,607 installs. Six of his mental models, applied in first person.

The closest thing to a first-party Karpathy skill is read-arxiv-paper (GitHub), a utility that ships inside his nanochat repo. It has 2,281 installs.

In other words: the third-party distillation of Karpathy's advice out-installs the skill in Karpathy's own repo by roughly 8x. The demand for one person's taste is strong enough that three different authors packaged it independently, and the packages are winning.

The Corey Haines case: the person who did ship

Corey Haines took the other path. He put his marketing playbook into a single repo, marketingskills, as installable skills.

The result, from live install data: 46 skills, 2,501,391 combined installs.

The top of the list:

seo-audit (GitHub): 162,532 installs
copywriting (GitHub): 152,682 installs
marketing-psychology (GitHub): 112,008 installs
content-strategy (GitHub): 107,419 installs
programmatic-seo (GitHub): 103,132 installs

SEO audits. Copywriting. Pricing pages. Cold email. These are not coding skills, and yet they sit in the same install rankings as debuggers and test frameworks, because the people installing them are software engineers who now ship marketing through the same agent that ships their code.

A year ago "marketing advice from a person you follow" meant a newsletter. Now it is 2.5 million installs of executable playbooks.

What this means if you build or use skills

First: when a catalog gets this large, names beat keywords. A trusted name compresses evaluation cost the same way a brand does. You cannot audit 60,000 skills, but you can decide you trust how Karpathy thinks about code review or how Corey Haines thinks about SEO, and search accordingly. Expect more of the top search terms to be people.

Second: if you have a public point of view, someone will eventually ship it as a skill. The only open question is whether that someone is you. Karpathy's coding advice reached 18,000+ installs without him lifting a finger, under someone else's repo. Haines shipped his own playbook and owns all 2.5 million installs of the distribution. If you have written advice developers act on, a SKILL.md is the highest-leverage format it can take right now.

If you want to watch this shift happen, the live data is public: the install leaderboard and the trending searches on the Skillselion homepage update daily.

Disclosure: I work on Skillselion, the directory these numbers come from: a live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs. Install counts pulled July 16, 2026.

Developers are not searching for more powerful Claude Code skills. They are searching for taste.

Skillselion — Mon, 13 Jul 2026 19:36:16 +0000

Pull the Google Trends breakout list for Claude Code skills this week and the demand does not match the discourse.

The loud posts are still about the 132-agent mega-stack: dozens of subagents, a wall of MCP servers, nested orchestration, a CLAUDE.md the length of a short novel. But the skills that are actually breaking out in search, and the ones developers are actually installing, lean the other way. They are about restraint. About taste. About making the model do less, more predictably.

That gap between what gets talked about and what gets installed is the whole story.

What developers are actually installing

Here is the shortlist from the live catalog, refreshed daily from skills.sh, GitHub and MCP registries and ranked by real installs. Every one of these makes the output better and quieter rather than handing the agent more power.

caveman - forces blunt, literal, no-hedging output; strips the filler and the "as an AI" throat-clearing. Skillselion · GitHub - 343k installs.
ui-ux-pro-max - a taste layer for interfaces: spacing, hierarchy, restraint, the things a model gets wrong by default. Skillselion · GitHub - 263k installs.
design-taste-frontend - opinionated frontend taste so generated UI stops looking generated. Skillselion · GitHub - 250k installs.
improve (shadcn) - a tight "make this better" pass that refines what you already have instead of regenerating it. Skillselion · GitHub - 22.4k installs.
karpathy-guidelines - Andrej Karpathy's coding taste, distilled into a skill the agent can follow. Skillselion · GitHub - 17.8k installs.
ponytail - minimal-code discipline: ship the smallest change that works, not the cleverest one. Skillselion · GitHub - 14.2k installs.
stop-slop - a filter that cuts the AI writing tells: the hedges, the rule-of-three, the "as an AI" tic. Skillselion · GitHub - 6.9k installs.

None of these add a tool. None of these spawn a subagent. Every one narrows what the model is allowed to do and how it is allowed to sound.

Why the quiet skills are winning

A more powerful setup gives you more surface area to go wrong. Another MCP server is another routing decision the agent can fumble. Another subagent is another context window to keep coherent. The marginal agent you bolt on rarely earns the coordination cost.

caveman is the clearest case. It adds no capability at all. What it does is govern the output, and 343k developers decided that governor was worth more to them than another agent. Most people, most of the time, will make the same call, and the install numbers say a lot of them already have.

There is a search signal underneath this too. When someone types "taste" or "stop slop" or "minimal" into Google, they are not looking for capability. They already have capability. They are looking for a governor on it. The breakout terms are the tell: the demand is for judgment, not horsepower.

Two things worth taking away

The install-ranked list disagrees with the discourse. The viral setups optimize for how impressive a screenshot looks. The installs optimize for what people keep using on Tuesday. When those two diverge, trust the installs.
Taste is now a distributable artifact. A year ago good taste lived in a senior engineer's head. Now it ships as a skill file that 250k people can install. That is a genuinely new thing, and it is the most underrated category in the ecosystem right now.

If you are stacking agents to feel productive, try deleting most of them and adding one taste skill instead. The install-ranked catalog says you will not miss the agents.

Skillselion is an independent directory of Claude Code, Codex and Cursor skills, MCP servers and marketplaces, ranked by real installs. Not affiliated with Anthropic, OpenAI or Cursor.

Matt Pocock's skills, mapped: the flow he teaches, every deprecation, and what replaced what (v1.1)

Skillselion — Sat, 11 Jul 2026 21:32:16 +0000

mattpocock/skills is the most-installed personal skills repo in the Claude Code ecosystem. By Matt Pocock's own count: "160K stars, 7.5m downloads... and no tutorial" (Jul 9, 2026). It is also unusually alive: skills get renamed, replaced, and publicly buried in a deprecated/ folder. This is the complete, sourced map as of v1.1 (July 8, 2026): the flow he teaches, every deprecation, and what replaced what. Every claim links to his exact post, changelog, or commit.

What is the intended flow?

Pocock's video tutorial (July 9, 2026) walks five skills and is explicit that the order is the point:

"Watch me walk through the essential skills: /grill-with-docs, /to-spec, /to-tickets, /implement, /code-review. It's the whole flow, end-to-end."

Read it as a pipeline, not a toolbox:

/grill-with-docs: a relentless one-question-at-a-time interview that sharpens the plan and writes terminology and decisions to docs as it goes. Pocock calls it "the easy entry point" (reply).
/to-spec: turns the conversation into a spec (a PRD) and publishes it to the issue tracker. No interview, pure synthesis.
/to-tickets: breaks the spec into tracer-bullet tickets, each declaring which tickets block it.
/implement: executes the tickets test-first at agreed seams.
/code-review: judges the diff on two axes: repo standards and conformance to the spec.

One prerequisite makes it portable: run /setup-matt-pocock-skills once per repo. "Works with literally anything you can connect to programmatically, with zero changes to the skills" (GitHub, Jira, Linear, or local files) (Jul 8, Apr 28).

Where does /wayfinder fit?

Above the flow. /wayfinder, the v1.1 headliner, plans work "too big for one agent session" as a shared map of investigation tickets. It plans; it does not build (aihero.dev doc). Pocock's positioning, in his words:

"/grill-with-docs? No I think that will remain the easy entry point. /wayfinder for intermediate/advanced users." (Jul 9)

"You'll find wayfinder intuitive, I promise. It's just a more organized and foolproof grill-me." (Jul 2)

/research and /prototype exist to feed it, "or can be used independently" (v1.1 announcement).

What was deprecated, and what replaced it?

Deprecated / removed	Replaced by	When	Source
/to-prd	/to-spec	v1.1, Jul 8, 2026	announcement
/to-issues	/to-tickets	v1.1, Jul 8, 2026	announcement
/diagnose	/diagnosing-bugs (rename, now model-invocable)	v1, Jun 17, 2026	v1 announcement
/zoom-out	deleted; ideas live in /improve-codebase-architecture	v1, Jun 17, 2026	reply
/qa	none (deprecated folder)	pre-v1	repo
/design-an-interface	none (deprecated folder)	pre-v1	repo
/request-refactor-plan	none (deprecated folder)	pre-v1	repo
/ubiquitous-language	ground covered by /domain-modeling (added in v1)	pre-v1	repo, v1

The deprecated folder's README is one line: "Skills I no longer use." On the culling philosophy, replying about an unused skill: "Yah I experimented with it, never used it, deprecated it and will remove it" (Jun 21).

A detail from the commit log: during the v1.1 release a sequential /to-plan skill was added at 13:11 UTC and unified away into /to-spec + /to-tickets at 13:18. Seven minutes (commit history).

Why did /to-prd become /to-spec?

Announced six days before v1.1, with an apology:

"/to-prd is changing to /to-spec. /to-issues is changing to /to-tickets. Apologies for the churn, but I've been wanting to make this change for a while and now's the time to do it." (Jul 2)

The reasoning is semantic, from the same thread: "Yep, /to-prd currently produces a spec. Tickets and issues are basically interchangeable" (reply). A skill's name is part of the prompt an agent reads, so the name now matches the artifact the next skill in the chain consumes. The same logic drove v1's split into model-invocable and user-invocable skills and its "63% reduction in token cost for skill descriptions" (v1 announcement).

What explicitly survived?

"/grill-me and /grill-with-docs still around" (Jul 6), and v1.1 shipped "crucial fixes to /grill-me". Install data agrees: grill-me is the repo's flagship at roughly 508k installs, ahead of grill-with-docs (424k) and tdd (400k).

How do you keep up?

Update: run npx skills@latest add mattpocock/skills (v1.1 announcement).
Watch the changelog on aihero.dev and his X profile. Every removal so far came with a successor or an explanation.
His video overview: 5 Claude Code skills I use every single day (YouTube, @mattpocockuk).
The living version of this map, with install counts and the full SKILL.md for every skill including the deprecated ones: Matt Pocock's skills, mapped on Skillselion.

Disclosure: I build Skillselion, an install-ranked directory of agent skills and MCP servers. Every quote above links to the original post and was verified against it before publishing. Skillselion is not affiliated with Matt Pocock or AI Hero.

Claude Code just got a built-in browser. 533,000 installs saw it coming

Skillselion — Sat, 11 Jul 2026 07:53:33 +0000

Yesterday Anthropic shipped a sandboxed browser inside the Claude Code desktop app. Cmd+Shift+B, and your agent can read docs, click through a signup flow, and poke at your local dev server without ever leaving the session. The announcement is sitting at roughly 1.7 million views and 16,000 likes in a day, which for a developer-tool feature is a small earthquake.

Here is the part nobody at the launch party mentioned: developers already voted for this feature, months ago, with installs.

What were developers installing before the browser arrived?

The install counts below come from the Skillselion live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

agent-browser (GitHub) - Vercel's browser-automation CLI for agents. 533,255 installs, which puts it in the top handful of skills across the entire catalog. Not top of the browser niche. Top of everything.
playwright-cli (GitHub) - Microsoft's Playwright driver for agent sessions, 82,449 installs.
playwright-best-practices (GitHub) - 59,422 installs for a skill that just teaches the agent to write non-flaky tests.
chrome-devtools (GitHub) - 13,334 installs from GitHub's own skill collection.
chrome-devtools-mcp (GitHub) - the Chrome team's official MCP server, 4,923 installs against a 46,640-star repo.
browser-automation (GitHub) - 5,732 installs.
a11y-debugging (GitHub) - 1,439 installs for accessibility audits driven from the agent.

Add that up and you get well over 700,000 installs of "give my coding agent a browser" across one directory. That is the single largest capability gap developers have been patching by hand.

Takeaway 1: browser access is the gap between an agent that writes code and an agent that verifies code. An agent that cannot load the page it just changed is doing open-loop control, and every developer who installed one of the tools above had already figured that out.

Does the built-in browser kill the browser-skill stack?

Mostly no, and the reason is scope.

The in-app browser is sandboxed and session-scoped. It is excellent at the read-and-poke loop: pull the docs for the library you are wiring in, click the button you just rendered, check the network tab equivalent, iterate. The tab-switching tax on that loop was real, and it is gone. That is what 16,000 people were cheering.

What it does not replace:

CI-grade end-to-end testing. Playwright skills exist so the agent writes tests that survive after the session ends. A sandboxed session browser produces no artifact your pipeline can rerun. The 82,449 installs of playwright-cli are not going anywhere.
Performance work. Tracing layout shifts and LCP regressions is DevTools-protocol territory, which is exactly why the Chrome team ships chrome-devtools-mcp as a full MCP server rather than a browsing feature.
Accessibility audits. a11y-debugging runs structured checks, not clicks.
Anything headless at scale. Crawls, form-fill batches, screenshot matrices: agent-browser exists precisely because a visible single tab is the wrong tool for that shape of work.

Takeaway 2: the built-in browser replaces glue, not the stack. Verification is consolidating into the agent, and the specialized layers (test generation, DevTools traces, a11y) are the parts that compound.

What should you actually do on Monday?

If you are on the Claude Code desktop app, update and try Cmd+Shift+B on your own dev server. Then look at what the heavy installers pair with it: the best-of catalog ranks browser, testing and debugging skills by live install counts, so you can see which of the tools above developers keep after the honeymoon.

The agents got eyes this week. The interesting question is what they look at.

I help maintain Skillselion, a directory of Claude Code, Codex and Cursor extensions ranked by real installs. Stats above are live catalog numbers as of July 11, 2026.

GPT-5.6 launched and developers immediately hit their usage limits. The fix is not a bigger plan

Skillselion — Fri, 10 Jul 2026 11:21:18 +0000

Yesterday OpenAI shipped the GPT-5.6 family (Sol, Terra, Luna) and folded Codex into a unified ChatGPT desktop app. Within hours, the loudest thread on X was not about benchmarks. It was a developer on the $200/month Codex plan reporting he now hits his 5-hour usage window with just one or two agents running Sol, a setup that was comfortable on GPT-5.5.

OpenAI claims roughly 54% better token efficiency for coding in this generation. Developers are discovering the opposite problem in practice: stronger models invite heavier consumption. An agent that runs longer eats the efficiency gain in raw volume, and every plan (OpenAI's 5-hour windows, Anthropic's limit windows, Cursor's credits) still caps you the same way. Tokens in, tokens out.

Here is the uncomfortable take: most of the tokens your coding agent burns are spent on context you did not need to send. Re-exploring the repo it explored yesterday. Re-reading a 900-line CLAUDE.md on every turn. Carrying a whole conversation into a task that needed three files. A bigger plan does not fix that. It just raises the ceiling on the same waste.

There is a second signal worth taking seriously. Claude Code shipped a /checkup command two days ago that scans for exactly this: unused skills, oversized CLAUDE.md files, config bloat. When the tool vendor starts shipping hygiene tooling, the waste is no longer a niche complaint: even the vendor is telling you your setup is burning tokens it does not need.

What developers actually install to spend fewer tokens

We track install counts across the live Skillselion catalog (refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs). Filtered to token and context efficiency, this is the ranked shortlist developers are voting for with their installs:

1. subagent-driven-development - 140,798 installs (GitHub)
Dispatch each task to a fresh subagent with a bounded context instead of dragging one long conversation through an entire plan. The parent pays for a summary, not the whole transcript. This is the single most installed context-control pattern in the catalog.

2. improve - 20,365 installs (GitHub)
shadcn's planning skill: survey the codebase once, produce prioritized, self-contained implementation plans that another agent can execute without additional context. That last clause is the token play. Sitting at #2 on our trending-in-search rail right now.

3. ponytail - 12,544 installs (GitHub)
Forces the simplest, shortest solution at every step and deletes speculative code before it exists. Flagged Breakout on our trending-in-search rail over the last 30 days. Minimal solutions are cheaper twice: fewer output tokens now, less code for the agent to re-read on every future turn.

4. context-engineering - 9,762 installs (GitHub)
Addy Osmani's take on deliberately curating what the agent sees, when it sees it, and how it is framed. The discipline layer the other skills assume.

5. context-map - 9,357 installs (GitHub)
Generate a precise map of relevant files, dependencies and tests up front, so the agent navigates instead of exploring. Exploration is the silent budget killer: every wrong file opened is paid for again in every later turn that carries it.

6. remembering-conversations - 8,891 installs (GitHub)
Recall relevant past sessions instead of re-deriving decisions. The cheapest token is the one you already paid for last week.

7. claude-md-improver - 6,960 installs (GitHub)
Anthropic's own auditor for CLAUDE.md files. Your project memory file is loaded on every single turn; a bloated one is a tax on everything. This is the standing version of what /checkup now does as a one-shot.

Two takeaways

Takeaway 1: usage limits are a context-engineering problem, not a pricing problem. The developers complaining loudest about 5-hour windows and the developers installing plan-first, subagent and memory skills are solving the same problem from opposite ends. One end costs $200/month more. The other is mostly free.

Takeaway 2: the install data says efficiency is becoming a default stack layer. Hygiene and context-control skills now sit among the most installed tools in the catalog, and the breakout search trends (ponytail, improve) are both efficiency plays. The ecosystem is maturing from "make the agent do more" to "make the agent carry less."

New models will keep landing every few weeks. GPT-5.6 today, the next Claude tomorrow. The developers who get the most out of every one of them are the ones whose setup sends the fewest wasted tokens per task. That stack is above, ranked by the people already running it.

Data: live Skillselion catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs. Install counts captured July 10, 2026.

I run Skillselion, a directory of Claude Code, Codex and Cursor skills, MCP servers and marketplaces ranked by real installs.

DEV Community: Skillselion

Claude Code talks too much. 375,000 installs say developers agree.

The numbers

Why this category exists now

The two fastest-growing Claude Code skill searches right now are both taste layers

Five risers, one pattern

Two things worth acting on

The fastest-rising Claude Code skill searches this week are about restraint, not power (July 20 data)

Two camps, one complaint

The restraint stack, ranked by installs

Why this matters if you run agents daily

Claude Code 2.1.215 Stopped Running /verify Automatically. Here Is the Better Workflow

Treat verification as a workflow stage

Ask hard questions before code exists

Keep feedback close to implementation

Make the evidence part of the handoff

CI is still the final shared contract

Fable 5 lands in every Max plan on July 20, at half limits. The install data shows what developers do about limits

We ranked this stack 8 days ago. Here is what happened since.

The limit-stretching stack, re-ranked for July 20

Two takeaways

Cursor can now code across Slack channels and repos. The hard part is agent coordination

1. Start with writing-plans

2. Parallelize only independent work

3. Give every subtask a fresh owner and two review stages

4. Make completion an evidence claim

5. Escalate failed verification into debugging

6. Request review with a fixed contract

A practical Slack-to-code contract

Claude Code's changelog now reads like a security bulletin. The skills developers install don't.

Agent security vs code security: what the install numbers say

Skills are dependencies. Almost nobody audits them.

How to audit your agent layer

The fastest-rising Claude Code searches this week are names, not tools

The Karpathy case: demand without supply

The Corey Haines case: the person who did ship

What this means if you build or use skills

Developers are not searching for more powerful Claude Code skills. They are searching for taste.

What developers are actually installing

Why the quiet skills are winning

Two things worth taking away

Matt Pocock's skills, mapped: the flow he teaches, every deprecation, and what replaced what (v1.1)

What is the intended flow?

Where does /wayfinder fit?

What was deprecated, and what replaced it?

Why did /to-prd become /to-spec?

What explicitly survived?

How do you keep up?

Claude Code just got a built-in browser. 533,000 installs saw it coming

What were developers installing before the browser arrived?

Does the built-in browser kill the browser-skill stack?

What should you actually do on Monday?

GPT-5.6 launched and developers immediately hit their usage limits. The fix is not a bigger plan

What developers actually install to spend fewer tokens

Two takeaways

1. Start with `writing-plans`