The most popular AI coding skills right now Agent skills—folders of markdown files that instruct AI coding agents—have become one of the most-starred new categories of developer tooling, with repos like Superpowers and a community-built skill based on Andrej Karpathy's advice amassing hundreds of thousands of GitHub stars. These skills, originating from Anthropic's SKILL.md format, work across agents including Claude Code and Kiro, and aim to fix common agent problems like rushing and skipping planning. Popular skills include Superpowers, a full development methodology that enforces spec-driven development, and the Karpathy-derived skill, which provides behavioral rules to prevent common LLM coding agent failures. 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 https://github.com/obra/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 https://kiro.dev/ 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: If you like, you can watch a full video https://youtu.be/enWhBCyU36U?si=wySkthIQYr6592m5 on the subject instead Also if nothing else, please check out the Agent Toolkit for AWS https://github.com/aws/agent-toolkit-for-aws More information below. Full disclosure, I'm a developer advocate for AWS 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 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 https://github.com/obra/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 https://www.skills.sh/obra/superpowers/brainstorming . 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 This one is almost the opposite. It is a short file of behavioral rules, now at 174,000 stars https://github.com/multica-ai/andrej-karpathy-skills . 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 collection https://github.com/mattpocock/skills 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 https://github.com/garrytan/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 https://github.com/open-gsd/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. 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 https://github.com/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 https://github.com/antfu/skills 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: @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. 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