I'll be honest — when I first heard about people building "skills" for AI coding agents, I rolled my eyes pretty hard. Honestly, Another prompt library? Another .claude file someone's gonna cosplay as open-source? I've seen this movie before. It was called "GPTs" in 2024, and it fizzled fast.
But then I started watching the numbers.
Not just stars — though we'll get to those. I'm talking about structural changes in how people actually build software. The kind you can't fake with a good README and a launch tweet.
Superpowers hit 245,000 GitHub stars. That's not a meme project. That's more than React. More than Vue. More than Kubernetes See what I'm getting at?
ECC, the agent harness system, sits at 225,000 stars. Andrej Karpathy's skill repackaged for Claude Code? 187,000 stars in five months. Matt Pocock's skills — 155,000. Garry Tan dumped his Claude Code config — 119,000 stars, basically instantly.
And the weirdest one of all? Caveman, a skill that makes your AI talk like it's from the Stone Age to save tokens, crossed 83,000 stars. Because of course it did.
Something's happening here. And it's not just a trend.
What Actually Is an "Agent Skill"?
Let's cut through the hype and define terms.
An agent skill is a structured prompt — usually a CLAUDE.md or AGENT.md file — that shapes how an AI coding agent behaves. It's the difference between asking Claude Code "write me a React component" and giving it a full context of your project's style, constraints, test patterns, and deployment workflow Make sense?
But calling it "just a prompt" is like calling Kubernetes "just a YAML file." The abstraction matters.
Here's what a real skill looks like (from Matt Pocock's repo):
# ~/.claude/skills/testing.md
You follow these testing rules:
- Write tests FIRST for all logic
- Use vitest for unit tests
- Prefer integration tests over mocks
- Never test implementation details — test behavior
- Coverage target: 90%+
You know what I mean?
Simple, right? Now imagine 20 of those stacked — for architecture, for deployment, for database migrations, for code review. That's what the skill frameworks do. They compose.
Garry Tan's gstack takes this further with 23 opinionated tools that act as entire roles: CEO, Designer, Engineering Manager, Release Manager, QA. Each one's a specialized skill with its own memory and context window.
"Your coding agent is only as good as the skills you give it." — common refrain in the AI Engineer World's Fair 2026, which is happening right now as I write this.
The Four Schools of Skill Design
Looking across the ecosystem, I see four distinct philosophies emerging:
1. The All-In-One Framework (Superpowers, ECC)
These are full operating systems for agentic development. Superpowers gives you a complete SDLC methodology — brainstorm, spec, implement, review, deploy — all orchestrated through skills. ECC (the name literally means nothing, it's just a brand now) bundles skills, instincts, memory, and security into a single harness.
Pros: Everything works together. One config, one workflow.
Cons: You're buying into someone else's philosophy. Hard to mix and match.
2. The Curated Collection (Matt Pocock, Addy Osmani, Karpathy Skills)
These are hand-picked, production-tested .claude directories from people who've actually shipped real products with AI agents. Matt Pocock's skills repo is literally his personal ~/.claude folder, open-sourced. Addy Osmani's agent-skills (68K stars) focuses on production-grade engineering patterns from Google Chrome's engineering team.
Pros: Battle-tested by people who know what they're doing.
Cons: May not fit your stack or workflow. Take what works, leave the rest.
3. The Opinionated Toolchain (gstack)
Garry Tan's approach is the most radical — each skill is an entire role with its own agency. The "Designer" skill doesn't just give design tips; it owns the design process from wireframes to specs. The "CEO" skill reviews PRs against business priorities.
Pros: Feels like having a whole team in your terminal.
Cons: High overhead. You need to trust the role definitions.
4. The Utility Belt (Caveman, Graphify)
These are focused, almost playful skills that solve one problem really well. Caveman cuts token usage by 65% by making the AI respond in terse, primitive language. Graphify turns any codebase into a queryable knowledge graph using RAG and Leiden clustering.
Pros: Low friction, immediate value.
Cons: Limited scope. They're tools, not systems.
The Cavman Effect: Why 83K People Want Their AI to Talk Like a Caveman
I've to pause on this one because it tells us something important.
Caveman is a Claude Code skill that literally prompts the AI to respond like a caveman. The author's tagline: "why use many token when few token do trick."
At first glance, this is a joke. And yeah, the README is hilarious. But 83,000 people didn't star it because they think caveman jokes are funny. They starred it because token costs are real.
A 65% reduction in tokens means 65% less API cost. For heavy users of Claude Code or Codex, that's not trivial — it's hundreds of dollars a month. Caveman is a statement about the economics of AI-assisted development, disguised as a meme.
And honestly? Some of the examples are genuinely more readable:
Before (verbose verbose):
I've analyzed the request and determined that the optimal approach would be to implement a caching layer using Redis, which would provide significant performance improvements while maintaining data consistency.
After (caveman):
Use Redis cache. Fast.
Consistent. Done. ```
I'm not saying you should write all your code like this. But there's a real insight here about how much of our AI interactions is wasted verbosity.
## The Economics of Skills: Who's Actually Making Money?
This is the part nobody talks about directly, so I'll.
Most of these skill repos are free and open-source. But the real money is in:
1. **Enterprise skill packs** — Teams paying for curated skill sets tuned to their stack
2. **Custom skill development** — Consulting shops building bespoke agent workflows
3. **Skill marketplaces** — Several startups are building platforms where you can sell premium skills
4. **Token savings** — Companies like Caveman that save 65% on API costs are effectively making money
Superpowers has a commercial tier. ECC has enterprise support. Graphify is building a paid knowledge-graph service on top of the free skill.
The skill itself might be free, but the ecosystem around it's increasingly monetized. If you're building in this space, think about where the value capture happens — it's not in the `CLAUDE.md` file. It's in the integration, the training, and the workflow optimization.
## The Dark Side: Skill Bloat and Prompt Hell
Let me be real about the downsides, because there're plenty.
**Skill bloat** is the biggest issue. I've seen teams with 40+ skill files, each one adding constraints and instructions. The agent becomes paralyzed — too many conflicting rules, too much context eaten by boilerplate, too many "don't forget to..." directives.
**Prompt conflicts** are real. What happens when Skill A says "always use TypeScript" and Skill B says "prefer plain JavaScript"? The agent has to reconcile them, and it usually does a bad job.
**Maintenance tax** is the silent killer. Skills aren't "set and forget." As your stack evolves, your skills need to evolve too. I've seen repos where half the skill files reference deprecated libraries or outdated patterns Make sense?
And the biggest unspoken issue: **most developers don't actually know how to write good skills**. Writing a skill is closer to writing a legal contract than writing code. You need to be precise, unambiguous, and anticipate edge cases. Most people aren't good at this.
## The Platform Play: Claude Code vs Codex vs Cursor vs Gemini CLI
Right now, Claude Code is the skill king. The `CLAUDE.md` format has become the de facto standard — even Codex and Cursor support it with `CODEX.md` and `.cursor/rules/` equivalents.
But the fragmentation is real:
| Platform | Skill Format | Ecosystem Maturity |
|----------|-------------|-------------------|
| Claude Code | `CLAUDE.md` | ✅ Most mature, widest adoption |
| Codex | `CODEX.md` / `AGENT.md` | ✅ Growing fast |
| Cursor | `.cursor/rules/` | ✅ Good, but Cursor-specific |
| Gemini CLI | `.gemini/` | ⚠️ Early stage |
| OpenCode | Custom YAML | ⚠️ Niche |
The winner here won't be the best format. It'll be the one that **reduces fragmentation**. I'm watching for a universal skill format — something like MCP for skills — and a few teams are already building it. If someone cracks that, they own the ecosystem See what I'm getting at?
## What I Think Actually Matters
After spending way too long reading skill files and watching the ecosystem, here's my honest take:
**The skill revolution is real, but we're in the "too many frameworks" phase.**
The best skill setups I've seen are small — 3-5 focused files that cover:
1. **Project conventions** — tech stack, patterns, style
2. **Testing philosophy** — how you write and think about tests
3. **Architecture rules** — invariants the codebase must maintain
4. **Deployment workflow** — how code gets from PR to production
Everything beyond that's noise.
The teams getting the most value aren't the ones with the most skills. They're the ones who iterated their skills based on what the agent actually got wrong. That's the real meta-skill: **observe, adjust, repeat**.
Garry Tan's approach of role-based skills is interesting, but I think it'll settle into something simpler. The CEO skill is novel. The "write a PR description that your actual CEO would understand" skill is probably more useful long-term.
## Bottom Line
The AI agent skill ecosystem is moving fast. Really fast. In the span of six months, we went from "maybe you can give Claude Code a few instructions" to 245K-star frameworks, celebrity developer configurations turned into products, and a caveman prompt that saves 65% on API bills.
If you're not already building skills for your workflow, you're leaving money and productivity on the table. Start with 3 files. Iterate. Pay attention to what your agent keeps getting wrong — that's your next skill.
And for the love of good code, don't install 40 skills at once. Your agent will thank you.
---
*This article was researched across HackerNews, GitHub trending, Dev.to, Reddit, and the AI Engineer World's Fair 2026. Star counts are from the GitHub API as of July 4, 2026.*
Top comments (0)