Eight Agent Skill Repos That Keep AI Coders in Line

The 8 Most Worth Installing Agent Skill Repositories on GitHub, Personally Tested and Great to Use!

Today I’ve put together 8 Agent Skill repositories on GitHub worth installing, ranging from 50k to 300k stars. These skill projects are also ones I use regularly. The star counts were pulled from the GitHub API on the day this was written, covering four types of needs: keeping a leash on the Agent’s code-writing hand, keeping a leash on the Agent’s aesthetic sense, helping the Agent read legacy code, and letting the Agent work inside your note database.

First, a quick recap of what a Skill is.

Anthropic launched Agent Skills last year. Essentially, it’s a folder with a SKILL.md inside that spells out what the Skill does, when to use it, and how to use it. Once installed, the Agent decides on its own whether to invoke it when working—you don’t have to change any configuration.

This format later became an open standard. Claude Code, Codex, Cursor, and WorkBuddy all recognize it. The 8 repositories below basically all provide installation instructions for each vendor’s Agent.

andrej-karpathy-skills: Constrain AI so it doesn’t write or change code randomly

Start with the lightest one.

Earlier this year, Karpathy posted on X, listing several chronic problems with LLMs writing code: they make assumptions for you, and they love to run wild—taking something that could be solved in a hundred lines and writing a thousand, casually changing code unrelated to the task. Some developers turned the post’s viewpoint into a repository, multica-ai/andrej-karpathy-skills, now at 220k stars.

Repository address:

https://github.com/multica-ai/andrej-karpathy-skills

The repo contains just one Skill, karpathy-guidelines, which enforces four principles when AI writes code:

Think Before Coding: State your assumptions first; ask questions when ambiguous; don’t fill in gaps and start coding.
Simplicity First: Only do what the requirements explicitly ask; refuse over-abstraction and extra features.
Surgical Changes: Only change code that needs changing; don’t refactor or reformat unrelated code on a whim.
Goal-Driven Execution: Establish a verifiable goal first, then iterate and validate.

Installation is simple too, and supports the standard skills CLI install.

Open a terminal (PowerShell/cmd/bash) in your project root and run:

npx skills add https://github.com/multica-ai/andrej-karpathy-skills --skill karpathy-guidelines

If you want a global install that affects all projects, add -g.

You can also use curl to download CLAUDE.md directly to the project root:

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

Put it in the project root. Any time you start claude in this directory, it automatically reads the constraints—no plugins or commands needed.

Install via plugin. Claude Code plugin global install (affects all projects):

/plugin marketplace add multica-ai/andrej-karpathy-skills, /plugin install andrej-karpathy-skills@karpathy-skills

Once installed, this Skill doesn’t require you to manually @ or wake it up each conversation. It’s a behavioral constraint rule. After installing it in the project’s CLAUDE.md or as a global skill, it takes effect automatically. If you installed via npx skills, you can explicitly invoke it in conversation with /karpathy-guidelines to force it on; after configuring globally, it defaults to automatic.

💡 Tips:

Suitable for: adding features, fixing bugs, refactoring.
For small changes (changing a word, fixing a simple typo), it will also follow these rules and be a bit verbose. In those simple cases, you can say: skip the karpathy rules and do a quick fix.

mattpocock-skills: Let the Agent grill you before you start

There are many ways an Agent can fail, but the most expensive one is when it starts working without understanding what you want, and only when you see the finished product do you realize it’s completely wrong. Matt Pocock’s judgment is that the solution lies before starting: have the Agent interview you instead.

Pocock has been teaching in the TypeScript world for years; Total TypeScript is his. This set of skills is the one he uses every day. At 300k stars, it’s the hottest among this batch. Nearly 40 Skills, split into engineering and productivity piles.

Repository address:

https://github.com/mattpocock/skills

The signature is the grill series:

/grill-me — Let the Agent ask follow-up questions about your plan, one at a time, drilling down every branch of the design tree until it truly understands what you want.
/grill-with-docs — An upgraded version that, while questioning, compiles project jargon into a GLOSSARY.md.

The README gives a before-and-after comparison. Get familiar with the common ones first; the full list is in the README.

Skill	Purpose
`/grill-me`	Question the plan in sequence, drilling down every branch of the design tree
`/grill-with-docs`	While questioning, maintain the glossary and architecture decision records
`/tdd`	Red-green-refactor loop, delivering one piece of functionality at a time
`/diagnosing-bugs`	Phased diagnostic loop for tricky bugs and performance regressions
`/implement-spec`	Concurrency implement the spec as a task graph, auto-running code review at the end
`/improve-codebase-architecture`	Scan the codebase for modules worth deepening, output a visual report
`/code-review`	Double-axis review of diffs, checking coding standards and requirement alignment in parallel
`/to-tickets`	Break a plan or spec into tickets with dependencies
`/triage`	Move issues through a state machine
`/teach`	Use the current directory as a workspace to teach you something new across multiple sessions
`/handoff`	Compress the session into a handoff document to let another Agent continue
`/wait-what`	When a message isn’t understood, ask for context and re-explain

There are two installation paths—plugin or skills CLI—pick one:

Claude Code users, one command from the official plugin marketplace, auto-updates after install:

claude plugin install mattpocock-skills@claude-plugins-official

Other Agents (Cursor, Codex, OpenCode, Windsurf, etc.), use the skills CLI, files get copied into the project, and you can modify them:

npx skills@latest add mattpocock/skills

In the same Agent, plugin and CLI only install one set. Installing both gives you two copies of every Skill. When the installer asks which Skills you want, make sure to check setup-matt-pocock-skills.

After installation, run /setup-matt-pocock-skills once in each repository. It asks which issue tracker you use, what the triage label is, where the docs live—all later Skills depend on this configuration.

You can also install individual Skills:

npx skills add https://github.com/mattpocock/skills --skill grill-me
npx skills add https://github.com/mattpocock/skills --skill tdd
npx skills add https://github.com/mattpocock/skills --skill diagnosing-bugs

Triggering is split two ways: /grill-me and /teach require you to type the command manually; /tdd and /diagnosing-bugs are auto-invoked when the Agent hits a suitable task. You don’t need to memorize all ~40; start with grill and tdd.

💡 Tips:

Suitable for: aligning requirements before coding, writing tests, diagnosing tricky bugs—real engineering work.
Its positioning is real engineering, not vibe coding. If you’re just throwing together a quick demo, it’ll feel like it asks too many questions.

ponytail: Solving AI over-engineering in code

Make the AI act like a “senior engineer who seeks minimalism but never cuts corners.” It solves the problems of AI writing too much code, generating lots of redundant code, and reinventing the wheel. The slogan: The best code is code that doesn’t need to be written.

DietrichGebert/ponytail does exactly that—stuffs this person’s thinking into your Agent. 170k stars.

Repository address:

https://github.com/DietrichGebert/ponytail

The repo contains just one Skill, ponytail. The core is a seven-step ladder. Before writing code, start from the top and find the first step that holds:

Level 1: Can this feature be skipped altogether?
Level 2: Does the codebase already have it?
Level 3: Can the standard library do it?
Level 4: Does a platform-native feature fit?
Level 5: Among already installed dependencies, is there something ready?
Level 6: Can it be done in one line?
Level 7: If none work, only then write the minimal working code, with a small test for any logic with side effects.

⚠️ Important constraint: pursuing fewer lines must never sacrifice validation, error handling, security, or accessibility. Simplification ≠ sloppily omitting safety logic.

The author gives a comparison in the README. Ask the Agent to add a date picker. Without the Skill, the Agent either installs a date library or hand-rolls a calendar, producing 335 lines. Ponytail first checks what’s in the project, finds an existing Input component, and the browser has a native date picker. Combine the two: 10 lines.

The author ran a benchmark of 39 tasks: code volume down 53%, tokens saved 45%, and the proportion of risky logic carrying tests rose from 68% to 98%. These are his own numbers—can’t verify—but the ladder itself is sound.

It states two bottom lines clearly. It’s lazy about writing, not about reading. Before picking a step, it reads the actual call chain involved in your change. Validation, security, and accessibility at trust boundaries are never cut, and the small required tests must stay.

Installation, pick one according to your Agent:

Claude Code, plugin method:

/plugin marketplace add DietrichGebert/ponytail
/plugin install ponytail@ponytail

Codex, after installing the plugin, trust its two lifecycle hooks in /hooks, and it takes effect in a new session:

codex plugin marketplace add DietrichGebert/ponytail
codex plugin add ponytail@ponytail

Other Agents (Cursor, Copilot, Windsurf, Cline, etc.), copy the repository’s AGENTS.md into the project root. See INSTALL.md in the repo for detailed steps per tool.

After installation, it auto-applies in every session—no manual wake-up. At critical moments, rely on three commands:

/ponytail-review — Review your diff with the mindset of a fire-fighting senior engineer, looking at bugs, security, and real load together.
/ponytail-audit — Do a health check of the whole repo, prioritized as a queue.
/ponytail-debt — Collect the shortcuts left in TODO: comments into a list, so “later” doesn’t become “never”.

💡 Tips:

Only recognize the two legitimate sources: DietrichGebert/ponytail (GitHub) and @dietrichgebert/ponytail (npm). The author states they never issue .exe or .dll files; anything with those is fake.
For Cursor, Windsurf, and other rule-file-based tools, what you install is resident rules, not slash commands.

agent-skills: Nine commands to run one development cycle

Addy Osmani has spent many years on the Google Chrome team. His approach differs from the previous two—not aimed at a specific flaw, but slicing the entire development lifecycle into nine slash commands.

/spec — write the spec first
/plan — break into small tasks
/build — implement piece by piece
/test — prove with tests
/review — gate before merging
/ship — ship it

Three more handle specific areas: /constraints sets quality red lines, /webperf measures page performance, and /code-simplify does subtraction.

Repository address:

https://github.com/addyosmani/agent-skills

The repo has 25 Skills grouped by define, plan, build, validate, review, and ship. The commands above are the entry points; the real work is done by the Skills behind them. What’s inside is Google’s engineering practice: Hyrum’s law in API design, the test pyramid and the Beyonce Rule in testing, Chesterton’s fence in code simplification. Every Skill has a uniform skeleton—steps, acceptance gates, plus a table of excuse rebuttals specifically for when the Agent says “I’ll add tests later.” Each excuse has a prepared rebuttal.

Two Skills stand out. interview-me asks one question at a time, peeling away ambiguous requirements layer by layer—same approach as Pocock’s grill. doubt-driven-development goes further: for high-risk decisions, it runs a self-confrontation round on the spot—first argue, then extract evidence, then doubt yourself, reconcile, and stop. For high-stakes changes, it’s worth the walkthrough.

The 25 Skills are grouped by lifecycle. Get familiar with the common ones first.

Stage	Skill	Purpose
Define	`interview-me`	One question at a time to nail down vague requirements
Define	`spec-driven-development`	Write a PRD spec before touching code
Define	`constraint-driven-development`	Turn quality red lines into a file to prevent the Agent from silently skipping checks
Plan	`planning-and-task-breakdown`	Break a spec into small verifiable tasks, ordered by dependency
Build	`test-driven-development`	Enforce red-green-refactor and the test pyramid
Build	`doubt-driven-development`	Run a self-opposition round on the spot for high-risk decisions
Build	`frontend-ui-engineering`	Component architecture, design systems, accessibility
Build	`api-and-interface-design`	Contract-first, boundary validation, Hyrum’s law
Validate	`debugging-and-error-recovery`	Five-step troubleshooting: reproduce first, then locate
Review	`code-review-and-quality`	Five-axis review, keeping changes in the low-hundreds of lines
Review	`code-simplification`	Chesterton’s fence: preserve behavior while subtracting
Review	`security-and-hardening`	OWASP Top 10, auth, key management
Ship	`shipping-and-launch`	Pre-launch checklist, canary release, rollback plan

Installation: the skills CLI works for all, or use the Claude Code plugin.

Universal method, skills CLI, one command to install all 25, works with 70+ Agents:

npx skills add addyosmani/agent-skills

To preview before installing, add --list; to install a single one, add --skill test-driven-development.

Claude Code plugin method:

/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills

After installation, type the nine commands manually; the Skills behind them activate automatically by task. For example, when you’re designing an API, api-and-interface-design attaches itself without you naming it. One pitfall: in Claude Code, /review conflicts with a built-in command, so use /agent-skills:review instead. You don’t need to install all 25. Get /spec, /build, and /review working first, then add others as needed.

💡 Tips:

Suitable for: teams that want to bake engineering discipline into the Agent—spec, test, review, and ship each have a corresponding Skill.
Installing only a single Skill won’t bring the shared references checklists from the repo, so a few checks will be missing. Full-repo install avoids this.

taste-skill: Let the Agent design with real images

AI-generated pages look fake at a glance. Why? The images feel generated, the layout smells like a template, and every site looks the same. Leonxlnx/taste-skill takes the approach of making the Agent work like a designer. It’s already at 100k stars.

Repository address:

https://github.com/Leonxlnx/taste-skill

The repo contains one Skill, design-taste-frontend. It forces the Agent to follow six steps when building a page:

Read the brief: list what only this client has
Set the direction: randomly deal three cards from twenty art directions; the Agent picks one
Bind the creative: in one sentence, bind the client’s materials and that direction into a single creative concept
Use real assets: build the page with real photos and videos from open libraries, using only public domain and CC-licensed works; the page auto-credits them
Self-check: in a real browser, check at three widths; template look means immediate failure
Wrap up: look at your own screenshots and fix the three most important issues, up to three rounds

Image sources include Wikimedia Commons, Openverse, and collections like the Metropolitan Museum. Those twenty directions were distilled from the author’s study of 247 hand-picked sites. Since v2.1, dashboards and app interfaces follow a separate track, with standards like quiet panels, honest numbers, and color spent on data, checked separately.

Installation is simple:

Universal method, skills CLI:

npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend"

Claude Code plugin method:

/plugin marketplace add Leonxlnx/taste-skill
/plugin install taste-skill@taste-skill

Environment requirements are just two: Node 22 or later and a Chrome (Edge or Chromium also fine). Nothing else to install, no API keys, and finding images requires internet access.

After installation, ask it to build a page and it will automatically run through the six steps—no manual wake-up. When done, you get the finished product plus screenshots.

💡 Tips:

Suitable for: proper landing pages and product pages. One run takes about 30–45 minutes and consumes several hundred thousand tokens. Don’t use it for a quick demo.
If the result isn’t satisfying, run it again—each run deals a different direction.

impeccable: AI Agent frontend design Skill

Paul Bakaus is an old hand in the frontend world, author of jQuery UI, later leading AMP at Google. His pbakaus/impeccable positions itself as a design language. Nearly 90k stars.

Repository address:

https://github.com/pbakaus/impeccable

Official site: https://impeccable.style

It started from Anthropic’s official frontend-design Skill and went two steps further. The first step is 24 sub-commands, all under /impeccable—effectively a shared design vocabulary between you and the Agent. A few common ones:

init: establish the product context and write it into a PRODUCT.md
audit: accessibility, performance, responsive technical checkup
critique: design review
polish: final pass before release
bolder: add punch to a boring design
quieter: cool down an over-the-top design
harden: specifically fill in error handling and edge cases

The second step is 62 deterministic checking rules, run directly by a CLI and browser plugin—no LLM, no key. The clichés of AI frontend—Inter font everywhere, purple-to-blue gradients, card stacked on card, gray text on colored backgrounds—are named outright in the rules. The model can promise to fix something, but if the rules don’t pass, it doesn’t get through.

Installation has a built-in installer:

Recommended method, the installer auto-detects which Agents you have installed and asks whether to install for the current project or globally:

npx impeccable install

For non-interactive script use, add --providers=claude,codex,cursor to specify tools and --scope=project or --scope=global to specify scope.

Claude Code plugin method:

/plugin marketplace add pbakaus/impeccable

After adding the marketplace, open /plugin and install Impeccable from the list.

After installation, run /impeccable init once in the project. It asks who the product is for and in what scenario, writes it to PRODUCT.md. All subsequent commands pull context from that file, so you won’t be asked each time.

💡 Tips:

The 62 rules run locally without LLM or keys, so hooking them into CI costs nothing.
Suitable for: pre-launch health checks of AI-generated pages. Pair it with taste-skill—one produces the effect, the other holds the bottom line. You can install both.

Understand-Anything: Turn 200,000 lines of code into a single image

Say you just joined a new team, the repo is 200,000 lines, and nobody has time to explain it. Where do you start? Egonex-AI/Understand-Anything is built for that scenario. 88k stars. It uses a multi-agent pipeline to scan the entire codebase, build a knowledge graph of every file, function, class, and dependency, then opens an interactive panel where clicking any node gives an explanation in plain language.

Repository address:

https://github.com/Egonex-AI/Understand-Anything

The command family is split by purpose; here’s the full table:

Command	Purpose
`/understand`	Main analysis: scan the entire repo, build the knowledge graph, then incremental updates
`/understand-dashboard`	Open the interactive visualization panel
`/understand-chat`	Ask the codebase questions directly, e.g., how does the payment flow work
`/understand-diff`	Before committing, see which areas this change will affect
`/understand-explain`	Deep-dive into a specific file or function
`/understand-onboard`	Generate a new-hire onboarding guide
`/understand-domain`	Map the code to business domains and processes
`/understand-knowledge`	Analyze a Karpathy-style LLM wiki knowledge base, outputting an entity-relationship graph

In principle, it separates two kinds of parsing. tree-sitter does deterministic structural parsing—the same code always produces the same edges. The LLM only handles the semantic layer, answering what a file is for. The graph is incremental: the second run only analyzes changed files.

What’s most practical for teams: the graph is just a JSON file, committed directly to the repo. Colleagues pull it down and open the panel with a single npx command—no LLM, no key needed.

Installation:

Claude Code, plugin method:

/plugin marketplace add Egonex-AI/Understand-Anything
/plugin install understand-anything

Other Agents (Codex, OpenCode, Gemini CLI, Trae, etc.), one-line installer. Without arguments, it asks which platform to install for:

curl -fsSL https://raw.githubusercontent.com/Egonex-AI/Understand-Anything/main/install.sh | bash

For non-interactive, specify the platform by replacing the ending with | bash -s codex.

After installation, run /understand in the project to build the graph. Add --language zh to get node descriptions and the panel in Chinese. Everything after is incremental. To auto-update the graph on every commit, use /understand --auto-update to attach a post-commit hook.

💡 Tips:

The first full-repo analysis consumes a lot of tokens. For large projects, run it within a subscription quota or connect a local model.
Large repos can scan just one subdirectory, e.g., pass a path like /understand src/frontend.

obsidian-skills: Written by Obsidian’s own CEO

Last but not least, the author of this repo, kepano, is Obsidian’s CEO Steph Ango. The note-taking software company itself came down to write a Skill for Agents, teaching it to work with Obsidian’s open formats and not mess up your note database. 50k stars.

Repository address:

https://github.com/kepano/obsidian-skills

There are 6 Skills total, each managing one area:

obsidian-markdown: write Obsidian-flavored markdown, with rules for wikilinks, callouts, and properties
obsidian-bases: operate .base files—the database views in your note library
json-canvas: create and edit .canvas canvas files
obsidian-cli: invoke Obsidian’s official command line, also managing plugin and theme development
defuddle: extract clean markdown from web pages before feeding it to the Agent, saving tokens
knap: take JSON or CSV data and batch-render markdown files from templates

Installation:

Claude Code, plugin method:

/plugin marketplace add kepano/obsidian-skills
/plugin install obsidian@obsidian-skills

Other Agents, skills CLI:

npx skills add https://github.com/kepano/obsidian-skills

No configuration needed. When the Agent writes .md, .base, or .canvas files in your note library, it automatically applies the corresponding format rules. Generated notes match hand-written formatting.

💡 Tips:

If your knowledge base is in Obsidian, install all 6—they’re tiny, no burden.
defuddle and knap aren’t tied to Obsidian; you can use them in any Agent to save tokens and batch-generate files.

Which to install first

Installation methods boil down to three paths. Claude Code users go the plugin route—all 8 have plugins. If you use multiple Agents, use npx skills add <repo address>, which works across mainstream tools. impeccable has its own installer, npx impeccable install.

My advice: pick by need.

Just want to try it out? Curl that Karpathy CLAUDE.md. Zero cost, effect in five minutes.

Use Claude Code daily for coding? Pick one of mattpocock/skills or ponytail to install for a week. One keeps you honest with questions, the other keeps code minimal. They don’t conflict, but you can only feel the difference after installing one first. If you write frontend often, taste-skill manages the result and impeccable holds the bottom line—you can install both. Just inherited a legacy project? Run Understand-Anything once. Knowledge base in Obsidian? Install all 6—they’re tiny.

Going through these 8 repositories, one impression stands out.

What’s truly valuable about Skill is turning a senior engineer’s judgment into a process an Agent can execute. Karpathy’s four rules, Ponytail’s seven-step ladder, the grill’s questioning—behind all of them is the working discipline of an old engineer. The repository is just the carrier. Installing ten is not as good as writing one based on one. The experience of that “Ponytail” in your team—how he judges whether something should be written, how he reviews code—organize that into a SKILL.md and let it sink in. That’s the biggest value this mechanism brings to a team.