Introduction

It's crazy to me that some GitHub repos, that were just created in the last year, have more stars then some of the most popular programming frameworks out there. At the time of writing, Superpowers, is around 226,000, ahead of the Vue repo and way ahead of Next.js. A separate repo based on Andrej Karpathy's coding advice has 174,000. And they aren't even code. They're folders of markdown files that tell your AI coding agent how to write software better.

In other words these are agent skills, and they've blown up over the past year into one of the most-starred new categories of developer tooling. The format started at Anthropic, a SKILL.md file with a short description and a set of instructions, and now it works in Claude Code, Kiro and all your other favorite coding agents.

This post is a tour of some of the skills I find most interesting that people are using everyday. I'll be in Kiro for most of this, but these run in whatever agent you already have, with install paths that vary per agent.

This post covers:

1. What an agent skill actually is
2. The big workflow skills (Superpowers, Karpathy, Matt Pocock, GStack, GSD)
3. Framework skills and the "ships with your package" model
4. The Agent Toolkit for AWS
5. How to pick one and try it safely

If you like, you can watch a full video on the subject instead! Also if nothing else, please check out the Agent Toolkit for AWS! More information below. Full disclosure, I'm a developer advocate for AWS

What is an agent skill?

A skill is a directory with a SKILL.md file inside it. The file has a name, a one-line description, and instructions. These instructions include which steps to follow, which APIs to call, which mistakes to avoid and how to check the result.

Skills should only run when needed. Your agent reads the short description, decides if the skill is relevant to what you asked, and only then loads the full instructions. Reference files load on demand after that. So you can have fifty skills installed and your context window stays clean, because the agent pulls in the two it needs and ignores the rest. In practice, I've found I still need to manually tell my agent to run the skills by using the / command and the skill name. YMMV

The big workflow skills

Most of the popular general-purpose skills are trying to fix the problem agents often have, going in the wrong direction. Agents when left alone often rush in, touch too many files, and they skip planning. These five take different approaches to slowing it down.

Superpowers (obra/superpowers)

Superpowers is the most-starred of the bunch and the most opinionated. It is a full development methodology that triggers automatically. It really reminds me of a super powered Spec-Driven Development (SDD) workflow.

The moment the agent sees you are building something, it stops and asks what you are actually trying to do. It works a spec out of the conversation, shows it to you (optionally in a web browser), and only after you sign off does it write an implementation plan. Then it hands the plan to subagents that build and review each other's work. Be aware, this can eat up a lot of tokens.

It is available through the official Claude plugin marketplace, plus Codex, Cursor, Gemini CLI, and a handful of others. You can also get it working with Kiro by from Skills.sh. Though, I'd probably skip it if you're using Kiro, since most of the SDD is already there in Kiro.

If you want one system that owns the whole loop from idea to reviewed code, this is the one to reach for. In Claude Code, install it from the official plugin marketplace:

/plugin install superpowers@claude-plugins-official

The Karpathy guidelines (multica-ai/andrej-karpathy-skills)

This one is almost the opposite. It is a short file of behavioral rules, now at 174,000 stars. Andrej Karpathy did not write it, despite the name, which I find really funny. It is a community-built file derived from a January post where Karpathy listed the ways LLM coding agents tend to fail, and the repo later moved to the multica-ai org.

The rules come down to four simple ideas. Think before coding, keep it simple, make surgical changes, and stay focused on the goal. If Superpowers feels like too much process for you, this is the low-commitment starting point. It is a single CLAUDE.md (or AGENTS.md, or you can use it as a Skill), so the simplest install is to drop it into your project:

curl -o CLAUDE.md https://raw.githubusercontent.com/multica-ai/andrej-karpathy-skills/main/CLAUDE.md

Personally, I'm not sure if this is worth it in my own testing. However, it's easy enough to add it to your own CLAUDE.md or AGENTS.md so give it a shot though and make your own opinion.

Matt Pocock's skills (mattpocock/skills)

Matt Pocock's collection sits in the middle and takes a deliberate stance against the all-in-one systems. In fact, he's often said he doesn't like SDD, and thinks it's too cumbersome. His framing is that approaches which own your entire process also take away your control and make bugs in that process hard to fix. So his skills are small, composable, and easy to adapt. You install the ones you want with the Vercel skills CLI:

npx skills@latest add mattpocock/skills

His most popular one, and the one I like the most, is the grill-me, which makes the agent interview you about what you are building before it writes anything. There is a more powerful version, grill-with-docs, that does the same interview and also builds a shared-language document for your project. The repo's pitch is that this shared-language document pays off across sessions. There is also tdd for a red-green-refactor loop, diagnose for debugging, and improve-codebase-architecture for rescuing a project that has turned into spaghetti.

Another skill called caveman helps reduce token costs. I find the caveman and grill-me skills the most useful. Though, I find grill-me a little annoying after a while, when I just want to get something done.

GStack (garrytan/gstack)

GStack is Garry Tan's Claude Code setup, and at nearly 110,000 stars it is one of the most popular skill collections out there. Instead of one mode that handles everything, it gives the agent distinct roles, each behind its own slash command. It has product vision, designer, engineering manager, release manager, doc engineer, QA, and post-launch retrospective. It is the same genre as Superpowers, a full workflow, but organized around the roles on a software team rather than a sequence of phases. If you think in terms of "who would handle this part," GStack maps to that mental model nicely. It installs with a clone and a setup script (pass --host kiro, --host cursor, and so on for other agents):

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git ~/.claude/skills/gstack
cd ~/.claude/skills/gstack && ./setup

It also works with Kiro nicely.

GSD Core (open-gsd/gsd-core)

GSD Core (Git. Ship. Done.) is a spec-driven system that pitches itself as a fix for context rot, the slow drop in quality as your context window fills up during a long session. It breaks work into atomic plans that run in fresh context windows, keeping the main session light while subagents do the heavy lifting. It targets more than a dozen agents. The project moved from the old gsd-build org to its current home at open-gsd/gsd-core, and the installer prompts for your runtime:

npx @opengsd/gsd-core@latest

While using this, I found that it burned through tokens fast. It also takes over your whole workflow, that I disliked. Still, it's worth trying out to see if it works well for your own personal projects.

Framework skills and the "ships with your package" model

The skills above are framework-agnostic. The more interesting development for frontend folks is skills that know your specific stack.

The Vue community moved early here. vuejs-ai/skills is a community Vue 3 skills project (the README notes the author may propose transferring it to the Vue org), and its vue-best-practices skill is a structured workflow covering the Composition API, reactivity, and the patterns you want a model to follow. Anthony Fu's collection covers Vue, Vite, Nuxt, Pinia, VueUse, and Vitest. Both install through the same CLI:

npx skills add vuejs-ai/skills
npx skills add antfu/skills --skill='*'

The newer idea is shipping skills inside the package itself. Three things are worth knowing:

• skilld generates version-aware skills from the npm dependencies you already have, pulling from docs, release notes, and GitHub issues. It solves the problem where a model's training cutoff means it writes last year's version of your library.
• TanStack Intent (@tanstack/intent) flips that around for maintainers. It lets library authors generate and ship SKILL.md files inside their npm package, versioned with each release, so the skill updates when the library does. It launched recently and ties straight into the TanStack ecosystem.
• The Vercel skills CLI is the npx skills tool that installs any of this across 70-plus agents. If you use Kiro, it loads skills from .kiro/skills/ automatically with no config, which makes it an easy way to try things on camera or in a real project.

Here is each of those three:

# Generate version-aware skills from your installed npm dependencies
npx -y skilld

# Library maintainers: scaffold SKILL.md files inside your own package
npx @tanstack/intent scaffold

# The universal installer used throughout this post — pattern is `npx skills add <owner/repo>`
npx skills add vercel-labs/skills

The Agent Toolkit for AWS

AWS ships skills too, in the same open format, so they run in Kiro, Claude Code, Cursor, and Codex.

The Agent Toolkit for AWS was announced in May 2026 and is the officially supported way to bring AWS expertise into your agent. It pairs plugins for Claude Code and Codex with a curated collection of skills and the AWS MCP Server, which reached general availability on May 6, 2026. The toolkit covers areas like deployment, serverless, and database work. Setup is per-agent. In Kiro you add the AWS MCP Server through your MCP config and then pull in skills with npx skills:

# Install AWS-curated skills via the universal CLI
npx skills add aws/agent-toolkit-for-aws/skills

If you are building on AWS, you should download this. Even if you are not using AWS I would download it for the future. Because with this the agent loads service-specific guidance instead of guessing at an API it half-remembers from training.

How to pick one and try it safely

Personally, I would use Matt Pococks skills and try out one of the other larger skill workflows like Superpowers. See if it works for you. Then pair it with a framework specific skills as well.

Last thing, and it matters. A skill is instructions you are dropping into your agent's context, so treat it the way you treat an npm dependency. Read the SKILL.md before you install it. A repo with 100,000 stars is popular, but stars are a popularity signal, not a quality review. Skim the file, see what it tells your agent to do, and keep the ones that match how you actually work.

Conclusion

Agent skills went from a quiet Anthropic format to repos with more stars than the frameworks we build on, and it makes sense why. They take the patterns a good engineer carries in their head and hand them to the model at the start of every task. The big workflow skills give you structure while the framework skills give you correctness, and the AWS plugins give you service-specific knowledge you would otherwise paste in by hand.

My advice: install one, read what it actually tells the agent, and see if the output matches how you'd have built it yourself. That's the real test, and it's the one only you can run. If you want to see these in action, I walk through them in the companion video.