"Skills" are taking over GitHub trending: obra/superpowers and mattpocock/skills are inventing the new standard for coding agents

"Skills" take over GitHub trending: obra/superpowers and mattpocock/skills invent the new standard for coding agents

🔎 Two collections of Markdown files crush the September 22 trending

Open the GitHub trending page for September 22, 2026 and look for the anomaly: the most prominent repos contain no model, no framework, no database. They are folders of Markdown files. obra/superpowers has surpassed 276,000 stars, mattpocock/skills is closing in on 232,000 — and openai/codex, despite launching at 1,541 stars per day, is trailing behind.

This is no flash in the pan. According to Max Quimby's analysis on dev.to, 5 of the top 8 trending repos belong to agent infrastructure. agentconn speaks of a "Cambrian explosion" and sees it as the biggest open source trend of 2026.

Why now? Because the container finally existed. The SKILL.md format, published by Anthropic in late 2025, spread within a few months across Claude Code, Codex, Cursor, and Gemini CLI. Developers found the sharing unit that was missing from their workflows with agents. They are starring the best implementations en masse.

The essentials

• GitHub trending on September 22, 2026 is dominated by two skills repos: obra/superpowers (276,000+ stars) and mattpocock/skills (232,000+), ahead of openai/codex (1,541 stars/day).
• A skill is a folder with a SKILL.md, automatically loaded by the agent when the task matches — a format published by Anthropic in late 2025, widespread by mid-2026.
• superpowers went from 29,400 stars on April 27, 2026 to 276,000 by late August, peaking at +6,175 stars/day.
• Three schools coexist: Superpowers' strict methodology, Osmani's 24 SDLC skills, and Pocock's compact utilities.
• The underlying question: is the skill becoming the knowledge-capture unit for coding agents, the way dotfiles were for personal config?

Recommended tools

All of them are free and open source. The real cost isn't financial: it's the discipline they impose on you.

What exactly is a "skill"? — A folder the agent loads on its own

A skill is a folder containing a SKILL.md file, which the agent automatically loads when the current task matches its description. No prompt to copy-paste, no plugin to install: the file is there, the agent finds it, the agent applies it.

This mechanism is what changes everything. The title of Max Quimby's article sums up the stakes: "Agent Skills Are the New Dotfiles". Dotfiles were how a developer capitalized on their personal configuration; the skill is how they capitalize on their way of working with agents.

Why it's more than a prompt

A copy-pasted prompt gets lost, contradicts itself, and forks into ten versions across a team. A skill is versioned, reviewable, shareable: it lives in a repo, goes through pull requests, and gets documented.

Above all, it's triggered by the task, not by the user's memory. Medium describes the new reflex: the agent first checks the available skills before diving into the code. It's the opposite of the 2025 reflex, where you'd cobble together a custom prompt at every session.

A format, not a product

Key point: SKILL.md is an open standard, not a proprietary product. Anthropic published it in late 2025; by mid-2026, Claude Code, Codex, Cursor, and Gemini CLI all support it. A skill written for one largely works with the others. It's this standard nature that explains the speed of adoption — and what sets this wave apart from the closed extensions of previous years.

obra/superpowers: a complete methodology, not a collection of tricks

Superpowers is not a bag of skills: it's a complete software development methodology, packaged as skills. Its official tagline, spotted on the agentconn listing, leaves no room for ambiguity: "agentic skills framework & software development methodology that works".

The pipeline comes down to six stages, and each one fixes a known shortcoming of coding agents:

1. Brainstorming — the design is refined Socratically before the first line of code. The agent questions your choices instead of running with your first instinct.
2. Isolation — work happens in separate git worktrees, not in your main checkout.
3. Written plans — the plan is broken down into 2-to-5-minute tasks, verifiable one by one.
4. Subagent development — each task is executed by a dedicated subagent, not in a saturated context.
5. Strict TDD — mandatory red-green-refactor cycles. The test exists before the code.
6. Two-stage code review — specification first, implementation second.

Debugging is systematic, not improvised. And the agent's autonomy can lead it to interrupt you to make you stick to the process.

Compatibility: where Superpowers hits hard

The framework works with Claude Code, Codex (app and CLI), GitHub Copilot CLI, Cursor, Kimi Code and OpenCode. That last point matters: as we detailed in our article on OpenCode, its 8 million devs and its 172K GitHub stars, the rise of open source agents is creating demand for portable methodologies. Superpowers is exactly that: a method that survives switching agents.

My take after reading through the pipeline: it's demanding, sometimes overbearing. That's a feature, not a bug. If you're looking for an agent that codes "fast and dirty", move along.

mattpocock/skills: "real software engineering, not vibe coding"

mattpocock/skills is the antithesis of vibe coding. Matt Pocock, known for his work on TypeScript, has extracted his personal skills from his .agents directory — its description fits in a single sentence: "skills for real engineering, not vibe coding".

The content is a distillation of engineering best practices: alignment with "grill-me" (a skill that asks you the hard questions before you start coding), domain modeling, TDD, structured debugging, two-axis code review, merge conflict resolution. All of it in Shell, under the MIT license.

The difference with Superpowers

Where Superpowers governs your entire project, Pocock's skills can be adopted à la carte. You take structured debugging today, code review tomorrow, without reorganizing the way you work.

And that's perhaps the most interesting signal from trending: a repo of personal skills — Markdown files and a few Shell scripts — has reached 232,000 stars. The hunger for methodology among devs using agents is massive.

The numbers from September 22: a measurable explosion

The numbers confirm unprecedented adoption for a dev methodology. The table summarizes the sourced readings:

Three readings of these numbers.

First, the speed. Ten weeks to go from 29,400 to 165,000 stars, with a peak of +6,175 stars per day: that's on par with the launch of a major open source LLM, except that here there are no GPUs or model weights to download.

Next, the breadth of the ecosystem. Medium counts more than 800,000 cumulative stars across ten skills repos. addyosmani/agent-skills is running around 77,000, alirezarezvani/claude-skills around 24,600. It's not two repos that are crushing it — it's an entire category.

Finally, the inverted hierarchy. openai/codex is gaining 1,541 stars per day as of September 22 — an excellent pace. It still trails two collections of Markdown files. An honest detail: the growth of the two leaders is slowing (+592/day in late August for superpowers). But the lead is such that the race behind is already lost. When methodological infrastructure outruns the giants' tools, it means the need wasn't being met.

Three schools, one standard: Superpowers, Osmani, Pocock

Beneath the same SKILL.md format coexist three distinct approaches, which the comparison by reasoncore.dev delineates well. The choice depends on your team's maturity, not on fashion.

The cleverest part of Osmani's repo: its anti-rationalization tables. Each skill documents the typical excuses agents use to skip steps — "the test isn't necessary here", "it's a trivial change". The agent looking to cut corners finds its objection pre-written in the table, and the table refutes it.

My ranking: Superpowers for teams that want to enforce a standard, Osmani for projects managed end to end, Pocock for senior devs who already know what they're doing and want targeted tools.

What it changes in your agent workflow

The fundamental change comes down to one sentence: the agent checks the available skills first before writing code. Everything else follows from that reflex.

Before, the typical sequence was: prompt, code, pray. Now: the task comes in, the agent loads the corresponding skill, the skill enforces design first, a written plan, tests before code, a two-step review. The dev goes back to being the one who makes the calls, not the one rewording prompts all day long.

The effects are already visible across the ecosystem. Cloudflare published a security audit skill that turns the agent into a security auditor (our analysis). Prime Agent, the repo that peaked at 17,500 stars, makes code agents self-improving — and auditable (our article). And ByteDance is pushing OpenViking, a self-evolving context base that unifies memory, RAG, and skills (our breakdown): there, the skill appears as one layer of a broader stack.

The skill above the model

A commonly misunderstood point: skills are model-independent. The same Superpowers pipeline runs with Claude Opus 4.7 from Anthropic, GPT-5.3 Codex from OpenAI, Gemini 3.1 Pro from Google, or a self-hosted Kimi K2.6. The skill structures the work; the model executes it.

That's good news for your independence: investing in skills means investing in something that doesn't become obsolete with the next model release. Unlike your prompts optimized for one specific model.

Are skills becoming the capitalization unit of agents?

Yes, and in my view that's the real story behind the trend. Not the stars, not the race between superpowers and mattpocock/skills: the mutation of what teams save.

For twenty years, a dev team's capital was its code and its docs. With agents, a third asset has emerged: the method by which we get code produced. Until now, that asset lived in internal documents nobody ever re-read, or in the heads of two seniors. The skill turns it into a versioned artifact, tested in production on every task, improvable via pull request.

agentconn goes further and sees superpowers as a candidate for the "canonical repository" of 2026, raising a real governance question: which problems deserve to become skills, which ones remain personal notes, and who reviews method changes within a team?

Two reservations, though. First: quality varies enormously from one repo to the next, and nothing certifies that a skill with 100,000 stars is right for your context. Second: fragmentation looms — three schools already coexist, and the philosophical incompatibilities (strict pipeline vs. à la carte) won't resolve themselves by magic.

But the direction is clear. The repos that win aren't the ones stacking the most skills: they're the ones packaging a coherent method. This is a market of method, not of quantity.

❌ Common Mistakes

Mistake 1: confusing a skill with a prompt

Copying the contents of a SKILL.md into your prompt is pointless: you lose automatic triggering, versioning, and composability. Install the skill in the directory your agent expects (Claude Code, Codex, Cursor, and Gemini CLI have supported this since mid-2026) and let the machinery do the rest.

Mistake 2: installing Superpowers without following the methodology

Adopting the framework and then coding "as before" while ignoring worktrees, 2-5 minute plans, and TDD means paying the price of a constraint without reaping its benefits. If the pipeline feels too heavy, pick Pocock's à la carte skills — but don't adopt Superpowers halfway.

Mistake 3: piling up 50 skills without governance

An uncurated skill library becomes noise: the agent loads contradictory instructions, and you no longer know which one caused what. Apply the same rigor to your skills as to your code: review, ownership, regular removal of anything that's no longer useful.

Mistake 4: believing the skill replaces model choice

A skill structures the work; it doesn't compensate for a weak model on the task at hand. For complex code, stick with the top-tier models — Claude Opus 4.7, GPT-5.5, Gemini 3 Pro Deep Think — and let the skill enforce the method. The two layers complement each other; they don't substitute for one another.

❓ Frequently Asked Questions

What exactly is an agent skill?

It's a folder containing a SKILL.md file that describes a skill: when the agent's task matches, the file is loaded automatically. The format was published by Anthropic in late 2025 and spread in mid-2026 across Claude Code, Codex, Cursor, and Gemini CLI. It's the basic unit for capitalizing on a working method with an agent.

Do these skills work with all coding agents?

The main ones support them: Claude Code, Codex (app and CLI), Cursor, Gemini CLI, GitHub Copilot CLI, Kimi Code, and OpenCode. superpowers is explicitly compatible with this list. Check your agent's documentation, but since mid-2026, the SKILL.md format has served as the de facto standard.

Superpowers or mattpocock/skills: which one should you choose?

Superpowers if you want a complete methodology imposed on the project: Socratic brainstorming, written plans, strict TDD, two-step review. Pocock's skills if you're an experienced dev who wants targeted utilities — structured debugging, code review, modeling — without reorganizing your workflow. The two complement each other very well.

Which model should you use with these skills?

Any of the recent models, since skills are model-independent. For demanding code: Claude Opus 4.7 (Anthropic), GPT-5.5 (OpenAI), or Gemini 3 Pro Deep Think (Google). Self-hosted: Kimi K2.6 or GLM-5 Reasoning. The skill provides the method, the model the execution capability.

Is it really free?

Yes: superpowers, mattpocock/skills (MIT license), and Osmani's agent-skills are open source and free (September 2026). The cost is that of discipline: TDD, written plans, mandatory reviews. And that of tokens, since multi-agent pipelines consume more context than a standard session.

✅ Conclusion

On September 22, 2026, two collections of Markdown files dominated GitHub trending ahead of OpenAI's tools: the skill became the unit of capitalization for coding agents, and superpowers like mattpocock/skills are its first reference points. Start by installing a single skill — Pocock's structured debugging is the most cost-effective — then let the method convince you.