Agent Skills Took Over GitHub Trending. Here's What They Actually Are

Six of the top repos on GitHub this week are agent skills. A skill is a folder with a Markdown file in it — here is why that format spread and what it costs.

Flat illustration of a folder shape with a single document inside it on a cream background
10 min read
1,935 words

Open GitHub’s weekly trending list today and most of the top of it is the same kind of thing: instructions for coding agents. Several are agent skills specifically — folders of Markdown that tell an agent how to do a particular job — and the rest are frameworks and instruction files doing a neighbouring job. The question worth answering is not how to write one, which half a dozen guides already cover. It is what this format is, why it spread so fast, and whether it changes anything for a team that is paying for AI tools and wondering what to do with them.

Why agent skills are suddenly everywhere

GitHub Trending listing showing claude-seo, impeccable, andrej-karpathy-skills, TradingAgents and superpowers in sequence, each with its total stars and stars gained this week
GitHub Trending, weekly view, captured 30 Oct 2026: five consecutive entries are agent instructions of one kind or another.

The numbers are worth reading carefully, because they are not what a trending list usually shows. obra/superpowers sits at 308,888 stars and gained 4,894 this week. multica-ai/andrej-karpathy-skills is at 226,572 and gained 4,250. pbakaus/impeccable is at 95,980, up 9,713. Cloudflare’s security-audit skill is at 53,200.

Not all of these are skills in the strict sense — TradingAgents is a trading framework and andrej-karpathy-skills is a single CLAUDE.md file — but the cluster is real, and claude-seo, impeccable, superpowers and Cloudflare’s audit skill all ship the format. These are also not new projects having a moment. They are large, established repositories accelerating at once, which is a different and more interesting signal: a packaging format that already existed is now being adopted by organisations with names on them. Cloudflare publishing one is the part that should make a sceptic look twice.

A skill is a folder, not a feature

Anthropic’s documentation is refreshingly plain about it: “Skills extend what Claude can do. Create a SKILL.md file with instructions, and Claude adds it to its toolkit.” That is the whole mechanism. A skill is a directory containing a file called SKILL.md, which holds some YAML frontmatter and then Markdown instructions.

.claude/skills/summarize-changes/SKILL.md

The frontmatter is barely a schema. Every field is optional — the docs say so outright, noting that only description is recommended “so Claude knows when to use the skill”. If you leave the description out, the first non-empty line of the file is used instead. The name defaults to the directory name and becomes a slash command, so a folder called deploy-staging gives you /deploy-staging. Unrecognised fields are ignored rather than rejected, and if the YAML fails to parse the skill still loads with no fields set.

Nothing here is a capability. The model does not gain a new power when you install a skill; it gains a written procedure, and the procedure is the thing you were going to paste into the chat anyway. Understanding that is most of what separates people who get value from this from people who install forty of them and wonder why nothing improved.

The reason the format spread: it costs nothing until used

This is the part that explains the trending list, and it is one sentence in the documentation: “skill descriptions are loaded into context so Claude knows what’s available, but full skill content only loads when invoked.”

That is progressive disclosure, and it changes the economics of written instructions. A long reference document pasted into a project file is in context on every single turn, paying for itself whether or not today’s task touches it — the same per-turn arithmetic that makes asking a decision model eight questions about one document cost more than asking it one. A skill’s description — a sentence — is the only part that is always present. The body arrives when the task matches and costs nothing the rest of the time. The docs make the guidance concrete: keep SKILL.md under 500 lines, push detailed material into separate files that load only when referenced.

This is why an organisation can publish a six-phase security methodology as a skill without making every unrelated conversation more expensive. Before this pattern, the choice was between a bloated always-on instruction file and instructions nobody could find.

What it replaces

For a team, the honest framing is not “a new AI capability” but “a place to put the things you keep retyping”. The documentation suggests exactly that trigger: reach for a skill when you keep pasting the same instructions, or when a section of your project’s instruction file has quietly become a procedure.

In practice that covers the deployment steps living in someone’s terminal history, the review checklist that exists as a bullet list in a wiki nobody opens, and the house style rules that get explained to every new hire and every new chat session. A project-scoped skill in .claude/skills/ is committed to the repository, so it arrives with the code and updates with it; a personal one in ~/.claude/skills/ follows you across projects instead. Where the names collide, the docs are explicit that enterprise settings override personal, and personal overrides project.

That is a documentation problem being solved by a loading mechanism, which is a strange sentence until you have watched a procedure rot in a wiki for two years. This is the same reasoning that makes a bounded, written brief the difference between an AI agent that works and one that quietly costs money.

Writing the first one

The minimum is smaller than people expect. A directory, a file, two lines of frontmatter:

---
name: summarize-changes
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed or wants a commit message.
---

Summarize the changes above in two or three bullet points, then list any risks.

Two rules about that frontmatter are worth knowing before you lose an afternoon. The opening --- must be the very first line of the file: if anything precedes it, the documentation warns that Claude Code “treats the whole file, --- markers included, as skill content”, and you get your YAML read aloud as instructions. And field names must match exactly, because unrecognised keys are ignored silently rather than erroring — a typo in a field name does nothing visible and changes nothing at all.

Three controls are worth reaching for once the first skill works. disable-model-invocation: true makes a skill manual-only, which is what you want for anything with side effects — it will not fire because the model thought it was relevant. user-invocable: false does the reverse, making it model-only. And paths limits automatic loading to matching files, so a skill about your database migrations stays dormant while you are editing CSS.

Start with the procedure you explain most often, not the most impressive one. A skill that reliably produces your commit-message format is worth more over a month than a sophisticated one that fires twice.

What a serious one looks like

Cloudflare’s security-audit-skill is the example to look at if you want the ceiling rather than the floor. It is MIT-licensed and turns a coding agent into a security auditor across six phases: reconnaissance, hunting, validation, structured output, record verification and reporting. Reconnaissance maps architecture, trust boundaries and input surfaces. Validation does something genuinely clever — the README’s instruction is to “give every unique candidate to a fresh verifier that tries to disprove it”, which is an adversarial check against the model’s own enthusiasm.

Installing it is one line:

npx skills add https://github.com/cloudflare/security-audit-skill --skill security-audit

Add --global for a user-level install rather than a project one. Then you ask the agent to audit a codebase and the procedure runs. The thing being distributed there is not software in any traditional sense. It is a method, written down, in a format an agent can load on demand.

It is not a Claude-only thing

The name on the documentation makes this look like a vendor feature, and in practice it is not. obra/superpowers — the 308,888-star framework from Jesse Vincent and the team at Prime Radiant — documents installation for roughly fifteen different agent harnesses, including Codex, Cursor, Devin CLI, Gemini CLI, GitHub Copilot CLI, Kimi Code, OpenCode and Qwen Code alongside Claude Code. Cloudflare’s skill installs through a generic npx skills add command rather than anything vendor-specific.

The caveat matters though: superpowers describes its skills as working across harnesses as a matter of practice and maintenance discipline, not because a formal portable specification exists. Each harness has its own install path. It is a convention that has spread, which is a weaker guarantee than a standard but a stronger one than a proprietary format.

There is one sharp edge where the convention meets a stricter gate. Uploading a skill outside Claude Code — to claude.ai or through the Skills API — accepts only six frontmatter fields: name, description, license, compatibility, metadata and allowed-tools. Any other key is a hard error rather than an ignored line. A skill that works locally with extra fields in its header will be rejected on upload, which is a surprising failure the first time it happens.

The costs nobody mentions

A loaded skill is a recurring cost. The documentation is direct about it: once a skill is invoked its content stays in context across turns, “so every line is a recurring token cost”. The cheapness is in not loading it, not in having it.

Descriptions get truncated at 1,536 characters. The combined description and when_to_use text is cut at that length in the listing, which is why the docs advise putting the key use case first. A description that buries the trigger past that cut risks never firing at all.

There are compaction budgets. After auto-compaction each invoked skill keeps its first 5,000 tokens, and re-attached skills share a combined budget of 25,000. A long session with several skills loaded is not carrying all of them in full.

allowed-tools is not a sandbox. It pre-approves tools for the invoking turn. The docs state plainly that it “does not restrict which tools are available” — if you read it as a permission boundary, you have misread it.

Installing someone’s skill is a trust decision. You are adding instructions that a model will follow, from a repository you probably have not read, to an agent that can run commands. The star count is a popularity measure, not a safety audit. Read the SKILL.md before installing it, which is realistic precisely because it is one Markdown file rather than a dependency tree — and apply the same question you would ask of any tool touching your work, which is where the data goes and what the terms actually say.

Whether you need one

The test is two pastes. If you have pasted the same instructions into an AI tool twice this month, that is a skill — write it down once, put it in the project, and let it load when it is relevant. If you have not, installing a trending framework will not create the need.

For most teams the first useful skill is not downloaded from anywhere. It is the four paragraphs explaining how your deployments actually work, which currently live in one person’s head and get re-explained every time. The format spreading across GitHub this week is, underneath the star counts, a very old idea: write the procedure down where the person doing the work will find it. The only new part is that the person is now a program, and the finding is automatic.

Sources

Every figure in this article traces to one of these. Dates are when the page was read.

  1. Skills
    AnthropicAccessed Oct 30, 2026Official docs
  2. Trending repositories, weekly
    GitHubAccessed Oct 30, 2026Official docs
  3. obra/superpowers
    GitHubAccessed Oct 30, 2026Official docs
  4. cloudflare/security-audit-skill
    GitHubAccessed Oct 30, 2026Official docs

Written by

Kai Devlin AI Automation Engineer

Full-stack developer who builds and runs AI automation systems in production. Runs local LLMs on personal hardware, builds N8N pipelines that actually ship, and deploys on Cloudflare Pages. Every guide on Pipeline Monk is tested on real consumer hardware — a Ryzen 7 5800HS with 16GB RAM and a GTX 1650. If it works on that, it works.