The Most Popular AI Coding Skills Right Now

A few months ago I noticed something strange while scrolling GitHub trending. A repository was sitting near the top with more stars than Vue. More than Next.js. And when I clicked through, expecting a framework or some clever runtime, I found... folders. Folders full of markdown files. No build step. No package.json at the root doing anything interesting. Just instructions, written in plain English, for an AI agent to read.

That repository was a collection of agent skills, and it turned out it wasn't an outlier. There's a whole category of these now, and several of them have racked up star counts that would make most open-source maintainers weep. People are starring folders of prose like they're the next big JavaScript framework. And honestly? The good ones deserve it.

This is the curated tour I wish someone had handed me when I started. I've installed all of these, run them on real work, watched some of them burn through my token budget like a teenager with a new credit card, and quietly uninstalled others within an hour. Below is the honest verdict on each — what it does, who it's for, and whether it earns the disk space.

What is an agent skill, exactly?

Before we get to the rankings, let's make sure we're talking about the same thing, because "skill" is one of those words that's been stretched in five directions.

An agent skill is, at its core, a directory containing a SKILL.md file. That file has three parts: a name, a one-line description, and a body of instructions. That's it. The format started at Anthropic as a way to give Claude reusable, on-demand expertise, and it has since spread well beyond — it now runs in Claude Code, Cursor, Kiro, Codex, Gemini CLI, and a growing list of other agents. The format is deliberately boring, which is exactly why it travels so well.

Here's the part that makes skills genuinely clever rather than just "saved prompts": they load progressively. The agent reads only the short one-line description of every installed skill at first. It does not load the full instruction body until the description matches what you're actually doing. So you can install thirty skills and your context window stays clean — the agent pulls in the "writing migrations" skill only when you're writing a migration, and ignores the other twenty-nine.

A skill is not a prompt you paste. It is a capability the agent reaches for when the situation calls for it — and ignores the rest of the time. That single design choice is why "install a hundred skills" is a sane sentence and "paste a hundred prompts" is not.

This is the mental model to hold onto: a skill is closer to an npm dependency than to a snippet. It's a unit of behavior you add to your environment, it can be good or bad or actively harmful, and — crucially — you should read it before you install it. We'll come back to that.

The quick comparison

If you only have thirty seconds, here's the whole roundup in one table. The verdicts and "who it's for" details follow below.

Skill	Stars (approx)	Best for	Install
Superpowers	~226k	Full spec-driven methodology, ambitious projects	/plugin install superpowers
Karpathy guidelines	~174k	A single sane behavioral nudge, zero commitment	clone & point your agent at it
Matt Pocock's skills	growing fast	Small composable skills, anti-monolith	clone the repo, pick what you need
GStack	~110k	Role-based slash commands across a project lifecycle	clone & copy commands
GSD Core	smaller, devoted	Fighting context rot with atomic plans	clone & follow setup
Vue / antfu skills	framework-scoped	Idiomatic Vue/Vite/Nuxt code	clone or npx skills add
skilld	npm package	Version-aware skills from your own deps	npx skilld
TanStack Intent	ships in package	Skills delivered with the library you install	install the package
Vercel skills CLI	tooling	Pushing skills to 70+ agents	npx skills
Agent Toolkit for AWS	official	AWS-native development with MCP + plugins	clone the toolkit

Star counts move fast and mean less than you think — more on that at the end. Treat them as a measure of attention, not quality.

Superpowers — the heavyweight champion

Repo: obra/superpowers · Stars: ~226k · Verdict: Astonishing when it fits, exhausting when it doesn't.

Superpowers is the most-starred and most-opinionated skill collection in the entire ecosystem, and it earns both titles. This is not a single skill — it's a full spec-driven methodology packaged as skills, with the whole thing wired together so the agent moves through a disciplined sequence: understand the problem, write a spec, plan the work, implement it, and review it.

The signature move is its use of subagents. Superpowers will spin up one agent to build a piece and a separate agent to review that piece, so you get something closer to a small engineering team than a single assistant typing into your repo. The review pass catches real mistakes. The spec pass forces you to actually decide what you want before any code gets written, which — if you've ever watched an agent confidently build the wrong thing for twenty minutes — you will appreciate deeply.

The cost is right there in the design: it can burn tokens. All that planning, speccing, and multi-agent reviewing is not free. On a small bug fix, Superpowers is wildly overkill, and you'll feel it both in latency and in spend. This is a methodology that wants to be used on ambitious work, where the upfront structure pays for itself.

# In Claude Code, install via the plugin system
/plugin install superpowers

# Then let it drive a real feature — not a one-line fix

Who it's for: Builders tackling a substantial feature or a greenfield project who want rigor and are willing to pay for it in tokens. If you already practice spec-driven development, this is the canonical expression of that philosophy. If you just want a quick edit, look elsewhere. The full breakdown lives on the Superpowers skill page.

The Karpathy guidelines — the low-commitment classic

Repo: multica-ai/andrej-karpathy-skills · Stars: ~174k · Verdict: The single best risk-to-reward ratio in this entire list.

Let's clear up the obvious question first: this was not actually written by Andrej Karpathy. The name is doing a lot of marketing work. What you actually get is a short, sober behavioral file that nudges the agent toward a handful of sane habits:

• Think before coding.
• Keep it simple.
• Make surgical, minimal changes rather than sweeping rewrites.
• Stay focused on the task at hand.

That's basically it. And here's the thing — it works. So much of what makes agents frustrating is that they over-build, wander off, and rewrite three files when you asked them to touch one line. A small file that says "don't do that" genuinely changes the texture of the output.

The beauty is the near-zero commitment. It doesn't take over your workflow, it doesn't spawn subagents, it doesn't burn tokens on elaborate planning. It's a few hundred words of behavioral guardrails. You can install it, forget it's there, and just notice that your agent is a little more disciplined.

# Clone it and point your agent's skills directory at it
git clone https://github.com/multica-ai/andrej-karpathy-skills

# No methodology to learn — it just shifts the agent's default behavior

Who it's for: Everyone, honestly. If you're skeptical of the whole skills concept and want a single low-stakes thing to try, start here. It's the gateway drug. Read more about why these behavioral nudges work in my prompt engineering guide, and see the Karpathy guidelines skill page for the full text.

Matt Pocock's skills — the composable counterargument

Repo: mattpocock/skills · Verdict: The most thoughtful design philosophy in the bunch.

Matt Pocock's collection is the deliberate anti-all-in-one. Where Superpowers hands you a complete methodology, Pocock's repo hands you a drawer of small, sharp, single-purpose tools and trusts you to compose them. This is a fundamentally different bet about how skills should work, and after using both styles, I find myself reaching for the composable one more often.

The standout is grill-me. Instead of taking your task and running off to build, it interviews you first. It grills you on the requirements, the edge cases, the things you haven't thought through — before a line of code exists. It's the cure for the most common failure mode in agentic coding, which is that you gave a vague instruction and the agent dutifully built a precise version of the wrong thing.

The supporting cast is excellent:

• grill-with-docs — same interrogation, but grounded in your actual documentation so the questions are specific to your stack.
• tdd — drives a genuine test-first loop instead of bolting tests on afterward.
• diagnose — a structured approach to debugging rather than the usual flailing.
• improve-codebase-architecture — steps back and looks at structure, not just the line in front of it.
• caveman — a deliberately stripped-down, blunt-instrument mode for when you want minimal cleverness.

git clone https://github.com/mattpocock/skills

# Then enable individual skills — don't install the whole drawer at once.
# Start with grill-me and see how it changes your kickoff conversation.

Who it's for: Developers who want control and prefer assembling their own workflow over adopting someone else's. If "a methodology that takes over my process" makes you twitch, this is your collection. Start with grill-me — it's the one I'd bet most people keep.

GStack — the role-playing studio

Repo: garrytan/gstack · Stars: ~110k · Verdict: A clever reframing — your repo gets a whole org chart.

GStack takes a different angle entirely. Instead of organizing skills by task (debug, test, plan), it organizes them by role. Each role is a slash command, and invoking it makes the agent step into a specific seat at the company:

• A product vision role to pressure-test what you're even building.
• A designer role focused on UX and interface decisions.
• An engineering manager role to break work down and sequence it.
• A QA role to hunt for the failure cases.
• A release manager role to handle the ship checklist.

There's something genuinely useful about explicitly switching hats. When you invoke the QA role, the agent stops trying to be helpful-and-agreeable and starts actively trying to break things — which is exactly the adversarial energy you want at that stage. The role framing makes the agent's behavior more legible: you always know which mode you're in and why.

The flip side is that it's a lot of ceremony for small projects. If you're fixing a typo, you do not need a release manager. GStack shines when you're carrying something through a full lifecycle and want each phase to have its own distinct mindset.

git clone https://github.com/garrytan/gstack

# Each role becomes a slash command — invoke the seat you need.
# /product-vision, /qa, /release-manager, etc.

Who it's for: Solo builders and small teams who want the discipline of having different "people" review their work at each stage. It pairs naturally with the agentic automation track, where orchestrating multiple roles is the whole game. See the GStack skill page for the full role list.

GSD Core — the context-rot warrior

Repo: open-gsd/gsd-core · Verdict: Surgical solution to a real problem, with a real cost.

GSD Core is built around one specific enemy: context rot. You know the symptom — you've been working with an agent for an hour, the context window is stuffed with old file reads and half-finished tangents, and the quality quietly degrades. The agent starts forgetting decisions it made twenty messages ago and contradicting itself.

GSD Core's answer is atomic plans executed in fresh context windows. It breaks work into small, self-contained plans, and each one runs in a clean context rather than dragging the accumulated cruft along. The result is that hour ten feels as sharp as minute one. For long, sustained work sessions, this is a genuine fix for a problem most people just tolerate.

The honest tradeoffs are twofold. First, it burns tokens — spinning up fresh context repeatedly is not cheap. Second, it takes over your workflow. This isn't a gentle nudge like the Karpathy file; GSD Core wants to be the way you work, structuring everything into its plan-execute rhythm. That's the right call for the problem it's solving, but go in knowing you're adopting a system, not adding a feature.

git clone https://github.com/open-gsd/gsd-core

# Follow the setup, then run long sessions and watch context stay clean.

Who it's for: People doing long, multi-hour agentic sessions on complex codebases who have felt context rot ruin the back half of their day. If your sessions are short, you won't feel the benefit and you'll just pay the token tax. Full details on the GSD Core skill page.

Framework skills — when the library teaches the agent

Here's the category I'm most excited about long-term, because it points at where this is all heading. Instead of a third party writing skills about a framework, the framework authors — and increasingly, the framework packages themselves — ship the skills directly.

Vue and the antfu collection

The vuejs-ai/skills repo provides vue-best-practices: idiomatic Vue patterns straight from the people who'd know. And Anthony Fu's antfu/skills covers an entire ecosystem in one place — Vue, Vite, Nuxt, Pinia, VueUse, and Vitest. When you're working in that stack, having the agent reach for genuinely idiomatic patterns instead of generic, slightly-out-of-date Stack Overflow Vue is a real quality jump. The agent stops writing Vue 2 habits into your Vue 3 project.

git clone https://github.com/vuejs-ai/skills    # vue-best-practices
git clone https://github.com/antfu/skills        # Vue/Vite/Nuxt/Pinia/VueUse/Vitest

The "ships with your package" model

This is the genuinely new idea, and I think it's the future of the whole space. What if the skill didn't live in a separate repo at all, but traveled inside the package you already install?

• skilld (npmjs.com/package/skilld) reads your project's npm dependencies and surfaces version-aware skills that match what you've actually got installed. No more agents writing API calls for v3 when you're on v5. The skill knows your version because it came from your node_modules.
• TanStack Intent (@tanstack/intent) is the maintainer-driven version: TanStack ships a SKILL.md inside their package. Install the library, and the agent automatically has expert, version-correct guidance for it. The library teaches the agent how to use itself.
• Vercel's skills CLI (npx skills) is the distribution layer for this whole movement — it can push skills out to 70+ different agents, so a skill written once reaches Claude Code, Cursor, Codex, and the rest without per-agent porting.

# Version-aware skills derived from your own dependencies
npx skilld

# Vercel's cross-agent skills CLI — add a skill to whatever agent you run
npx skills add <skill>

The endgame here is obvious and good: you npm install a library and the agent instantly knows how to use that exact version correctly, because the maintainers shipped the knowledge alongside the code. No stale tutorials. No guessing. The docs and the skill are the same artifact.

Who it's for: Anyone working in a framework that ships skills — which is a rapidly growing list. If you're a Vue or TanStack developer, turn these on today. If you maintain a library, start thinking about shipping a SKILL.md in your package; see the ship-skills-with-package skill page and the skilld page for how this works in practice.

Agent Toolkit for AWS — the official enterprise entry

Repo: aws/agent-toolkit-for-aws · Verdict: The grown-up, vendor-backed option.

When a major cloud provider ships its own skills, it signals the format has crossed from hobbyist enthusiasm into infrastructure. The Agent Toolkit for AWS is exactly that: an official, AWS-maintained bundle that combines skills + plugins + the AWS MCP Server.

The MCP Server piece matters. Skills tell the agent how to think about AWS; the MCP server gives it live, structured access to actual AWS context and operations. Together you get an agent that understands AWS best practices and can act on real resources through a sanctioned, official channel rather than improvising shell commands against your account. For anyone who's nervous about pointing an autonomous agent at production cloud infrastructure — and you should be nervous — having the vendor define the guardrails is reassuring.

git clone https://github.com/aws/agent-toolkit-for-aws

# Wire up the skills, plugins, and AWS MCP Server per the toolkit docs.

Who it's for: Teams building on AWS who want their agent to follow AWS-sanctioned patterns and connect through official tooling rather than ad hoc scripts. If "is this the AWS-blessed way to do it?" is a question your org asks, this is your answer. More on the Agent Toolkit for AWS skill page.

How to actually pick one (and try it without regret)

You've now got a menu. Here's how I'd navigate it without installing everything at once and ending up with a confused agent.

Start with your pain, not the star count. Map the problem to the tool:

• Agent over-builds and wanders → Karpathy guidelines.
• You give vague instructions and get precise-but-wrong results → grill-me.
• Big ambitious feature that needs rigor → Superpowers.
• Quality degrades over long sessions → GSD Core.
• You want lifecycle discipline with distinct review stages → GStack.
• You work in a specific framework → the framework skills for your stack.
• You're on AWS and want official guardrails → Agent Toolkit for AWS.

Treat a skill like a dependency, because it is one. Three rules I follow without exception:

1. Read the SKILL.md before you install it. It's plain markdown — it takes two minutes. You are about to give this file influence over what an autonomous agent does to your codebase. You would read a dependency that could write to your repo; read this. Some skills are aggressive, spawn subagents, or quietly change broad behavior. Know that going in.
2. Stars are popularity, not a quality review. A repo with 174k stars and a famous person's name on it is not a code review. (Remember: the "Karpathy" skills weren't written by Karpathy.) Stars measure attention. Your reading of the actual instructions measures quality.
3. Install one at a time and feel the difference. Add a skill, do real work, notice what changed. If you bulk-install ten skills you'll never untangle which one is responsible for the agent's new behavior — good or bad.

Lean on progressive loading. Once you've vetted a handful, the architecture is on your side. Because skills only load their full instructions when relevant, keeping a small curated set installed costs you almost nothing in context. The discipline isn't in keeping the list short — it's in only installing things you've actually read.

That's the whole game. The barrier to entry is gloriously low: every one of these is a folder of markdown you can read in full before it touches anything. There's no excuse not to look before you leap. Pick the one that matches your actual pain, read its instructions, try it on real work, and keep what earns its place.

Resources & links

External repositories and packages:

• Superpowers — obra/superpowers — the most-starred collection; full spec-driven methodology with subagent build-and-review.
• Karpathy guidelines — multica-ai/andrej-karpathy-skills — short behavioral nudge file (not actually by Karpathy), lowest commitment.
• Matt Pocock's skills — mattpocock/skills — small composable skills including grill-me, grill-with-docs, tdd, diagnose, and more.
• GStack — garrytan/gstack — role-based slash commands across the project lifecycle.
• GSD Core — open-gsd/gsd-core — atomic plans in fresh context windows to fight context rot.
• Agent Toolkit for AWS — aws/agent-toolkit-for-aws — official AWS skills, plugins, and MCP Server.
• Vercel skills CLI — vercel-labs/skills — npx skills, pushes skills to 70+ agents.
• Vue skills — vuejs-ai/skills — vue-best-practices, idiomatic Vue.
• antfu/skills — Vue, Vite, Nuxt, Pinia, VueUse, and Vitest skills.
• skilld on npm — version-aware skills derived from your installed npm dependencies.

Skill pages on this site:

• Superpowers
• GStack
• GSD Core
• grill-me
• Agent Toolkit for AWS
• skilld
• Ship skills with your package
• Karpathy guidelines

Guides and tracks to go deeper:

• Spec-driven development with AI agents — the methodology Superpowers is built on.
• The complete prompt engineering guide for 2026 — why behavioral nudges like the Karpathy guidelines work.
• Agentic automation track — orchestrating roles and multi-agent workflows end to end.