Super Claude on ICE-ICE-BEAR-BLOG

The Claude Code Skills Explosion — What Five Repos in One Day Are Telling Us

Sun, 10 May 2026 00:00:00 +0900

Overview

Five Claude Code skill and agent collection repos surfaced around the same time on 2026-05-10. One is Andrej Karpathy’s own autonomous research agent. One is Matt Pocock’s engineering-grade skill set. One is a full meta-framework called SuperClaude. This is not a coincidence — it is a sign that “skill” has crystallized into the primary primitive for agent engineering.

graph TD
 Pattern["skills pattern"] --> K["karpathy/autoresearch <br/> 80K stars"]
 Pattern --> F["forrestchang/andrej-karpathy-skills <br/> 123K stars"]
 Pattern --> A["hesreallyhim/awesome-claude-code <br/> 43K stars"]
 Pattern --> S["SuperClaude_Framework <br/> 22K stars"]
 Pattern --> M["mattpocock/skills <br/> 69K stars"]

 K --> Primitive["program.md = skill"]
 F --> Primitive
 M --> Primitive
 S --> Primitive
 A --> Curation["awesome-list curation"]

Why Skills Are Crystallizing

A skill is the pattern Anthropic formalized in fall 2025. The format is dead simple — a folder, a SKILL.md, optional helper scripts. Claude Code looks at the user’s task context and decides which skill to invoke itself.

That simplicity is the reason for the explosion.

Version-controllable — it’s just text. Review with git diff, accept PRs against it.
Composable — one skill can call another. /grill-me → /to-prd → /to-issues → /tdd becomes a natural pipeline.
Model-agnostic in spirit — Claude Code is the first mover, but the format is markdown, so it ports trivially. SuperGemini and SuperQwen forks already exist.
Shareable — pull an entire repo into your agent with /plugin marketplace add.

These five repos are five facets of that pattern crystallizing.

1. karpathy/autoresearch — Skill as a Research Agent’s program.md

karpathy/autoresearch sits at 80,223 stars. Created 2026-03-06, “AI agents running research on single-GPU nanochat training automatically.”

The idea is simple. Hand an AI agent a small but real LLM training setup and let it experiment overnight. Modify code → train 5 min → compare → keep or discard → repeat. You wake up to a log of experiments and (hopefully) a better model.

The structure is what matters.

prepare.py — constants, data prep (do not modify)
train.py — model/optimizer/training loop (agent edits this)
program.md — agent instructions (human edits this)

Karpathy himself states it in the README:

The program.md file is essentially a super lightweight “skill”.

That’s the line. Karpathy chose the word “skill.” Not a 10,000-line framework wrapping autonomous research orchestration on top of nanochat training code — one markdown file. The human evolves program.md. The agent evolves train.py. Two meta-evolution loops, cleanly separated.

Why this matters — Karpathy is the last person you’d expect to outsource a training setup. If he ends at one markdown file, everyone else has license to simplify harder.

2. forrestchang/andrej-karpathy-skills — Skills as Behavioral Correction

forrestchang/andrej-karpathy-skills has 123,691 stars. “A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy’s observations on LLM coding pitfalls.”

It distills four principles from Karpathy’s X post on LLM coding pitfalls.

Principle	Addresses
Think Before Coding	Wrong assumptions, hidden confusion, missing tradeoffs
Simplicity First	Overcomplication, bloated abstractions
Surgical Changes	Touching unrelated code, “improving” things you shouldn’t
Goal-Driven Execution	Loop until verifiable success criteria

Installation is two paths — /plugin marketplace add forrestchang/andrej-karpathy-skills for Claude Code, or curl the CLAUDE.md into your project. The same ruleset is committed as .cursor/rules/karpathy-guidelines.mdc for Cursor.

The thesis quote:

“LLMs are exceptionally good at looping until they meet specific goals… Don’t tell it what to do, give it success criteria and watch it go.” — Karpathy

This is skills used as a ruleset that corrects model behavior. Not adding capabilities — subtracting failure modes.

3. mattpocock/skills — Skills For Real Engineers

mattpocock/skills sits at 69,128 stars, MIT, last pushed 2026-05-10. “Skills for Real Engineers. Straight from my .claude directory.”

This repo stakes out an explicit position against full-process frameworks like GSD, BMAD, and Spec-Kit. The README is blunt:

Approaches like GSD, BMAD, and Spec-Kit try to help by owning the process. But while doing so, they take away your control and make bugs in the process hard to resolve.

These skills are designed to be small, easy to adapt, and composable. They work with any model.

Matt’s four failure modes and their skills:

Failure mode	Skill
#1 The Agent Didn’t Do What I Want	`/grill-me`, `/grill-with-docs`
#2 The Agent Is Way Too Verbose	`CONTEXT.md` shared language (built into grill-with-docs)
#3 The Code Doesn’t Work	`/tdd`, `/diagnose`
#4 We Built A Ball Of Mud	`/to-prd`, `/zoom-out`, `/improve-codebase-architecture`

Installation goes through the skills.sh installer:

npx skills@latest add mattpocock/skills

After install, /setup-matt-pocock-skills configures your issue tracker (GitHub / Linear / local files), your triage label vocabulary, and your doc storage path. From there, to-issues, to-prd, triage, diagnose, tdd, improve-codebase-architecture, and zoom-out all wire together against the same convention.

Pocock’s reading list is itself a signal — Pragmatic Programmer, Domain-Driven Design, Extreme Programming Explained, A Philosophy of Software Design. The argument: skills are not a new paradigm, they are an LLM-shaped interface to 30 years of software engineering practice.

4. SuperClaude_Framework — A Meta-Programming Layer On Top of Skills

SuperClaude-Org/SuperClaude_Framework has 22,726 stars, MIT, homepage superclaude.netlify.app. Created 2025-06-22.

Opposite pole from skill minimalism.

Metric	Count
Slash Commands	30
Specialized AI Agents	20
Behavioral Modes	7
MCP Servers	8

Self-described as “a meta-programming configuration framework that transforms Claude Code into a structured development platform through behavioral instruction injection and component orchestration.”

Install via PyPI:

pipx install superclaude
superclaude install

Headline commands — /sc:research (deep research, Tavily MCP), /sc:brainstorm, /sc:implement, /sc:test, /sc:pm. Optional MCP servers — Serena (2-3x faster code understanding), Sequential (30-50% fewer tokens), Tavily, Context7 — all routed through airis-mcp-gateway.

v5.0 is in development, with a TypeScript plugin system tracked in issue #419. Once shipped, install drops to /plugin marketplace add SuperClaude-Org/superclaude-plugin-marketplace.

What SuperClaude proves — skills are stable enough that a meta-framework can rest on top of them without collapsing. And the fact that the same format ports to Gemini and Qwen is empirical evidence of model-neutrality.

5. hesreallyhim/awesome-claude-code — The Curation Layer

hesreallyhim/awesome-claude-code has 43,273 stars, created 2025-04-19 — the oldest of this set. “A curated list of awesome skills, hooks, slash-commands, agent orchestrators, applications, and plugins for Claude Code by Anthropic.”

It follows the awesome-list convention. The repo’s topic tags are revealing — agentic-coding, agent-skills, ai-workflow-optimization, coding-agents. The README currently notes “the previous Table of Contents was no longer fit for purpose” and is mid-reorganization — which is itself the message. The Claude Code ecosystem has outgrown what one awesome-list can hold.

Why this repo belongs in the set: the other four provide new skills. This repo solves where to find them. Curation is itself a meta-skill.

Insights

1. Skill is now the consensus primitive. Five different people, five different angles, all settling on the same word. Karpathy’s program.md, Matt Pocock’s SKILL.md, SuperClaude’s slash commands — all framed as “skills.” The prior generation of terms (“prompt template”, “agent rules”, “system message”) has collapsed into a single noun.

2. Full-process frameworks vs. micro-skills is the live fault line. SuperClaude (30 commands) and Matt Pocock (small, composable) surfacing the same day is coincidence, but the split is real. Both survive. The interesting move is Pocock explicitly naming GSD/BMAD/Spec-Kit as the opposition.

3. Skills are used to subtract failure modes, not just add capabilities. Forrest Chang’s Karpathy guidelines give the model no new abilities. They prevent behaviors. What Anthropic does at the model level with Constitutional AI, users now do at the workflow level with skills.

4. Skills are the substrate of model neutrality — Claude Code is just the first surface. SuperClaude maintains SuperGemini and SuperQwen forks. Forrest Chang ships a Cursor .mdc in the same repo. Matt Pocock writes “They work with any model” as a top-line selling point. As the format standardizes, IDE/model lock-in weakens.

5. The program.md pattern has reached training code. In autoresearch, the human-edited file and the agent-edited file are physically separated. If that generalizes, every automated codebase trends toward a human.md + agent-modifiable/ shape.

6. What comes next — skill marketplaces, skill SDKs, skill evals. /plugin marketplace exists. SuperClaude is listed on Smithery. skills.sh emerged as a separate installer. The missing pieces are quality evaluation (which skills actually improve model output) and a skill SDK (build/test skills as if they were code).

7. Curation itself becomes a skill. awesome-claude-code earning 43K stars is the symptom of “there are too many skills to triage manually.” That’s the cue for a meta layer.

References

Source repos

karpathy/autoresearch — Single-GPU nanochat autonomous research agent. Calls program.md a “lightweight skill” explicitly.
forrestchang/andrej-karpathy-skills — Four-principle CLAUDE.md derived from Karpathy’s LLM coding pitfall observations.
mattpocock/skills — Small, composable engineering skills. Explicit counter to GSD/BMAD/Spec-Kit.
SuperClaude-Org/SuperClaude_Framework — Meta-framework with 30 slash commands, 20 agents, 8 MCP servers.
hesreallyhim/awesome-claude-code — Awesome-list for Claude Code resources.

Background

Anthropic: Introducing Skills — Skill format formalization.
Claude Code docs: Plugins — /plugin marketplace system.
Karpathy’s LLM coding pitfalls tweet — Origin of the Forrest Chang guidelines.

Related

awesome-list convention — Format awesome-claude-code inherits.
skills.sh — Matt Pocock skill installer.
Smithery — MCP/skill marketplace.

The OS Layer for AI Coding Agents — agentmemory and agent-skills Land the Same Day

Fri, 08 May 2026 00:00:00 +0900

Overview

Two GitHub links, dropped 30 seconds apart at the same minute. Both target ergonomic gaps in AI coding agents, but they target different gaps. rohitg00/agentmemory tackles cross-session memory infrastructure; addyosmani/agent-skills tackles senior-engineer workflow enforcement. Read together, they sketch out an emerging OS layer for the agent era.

Update 2026-05-10: Four new skills repos surfaced shortly after this post and reinforce the argument — covered in a new section below.

graph TD
 Agent["AI coding agent"] --> Memory["Memory / state layer"]
 Agent --> Skills["Workflow / rules layer"]
 Agent --> Model["Model layer"]
 Agent --> UI["UI layer"]

 Memory --> AM["agentmemory <br/> MCP + REST"]
 Skills --> AS["agent-skills <br/> Markdown skill bundle"]
 Model --> LLM["Claude / GPT / Gemini"]
 UI --> Tools["Claude Code / Cursor / Cline"]

1. agentmemory — Persistent Memory Shared Across Every Agent via MCP

rohitg00/agentmemory brands itself as "#1 Persistent memory for AI coding agents based on real-world benchmarks." Created 2026-02-25, ~2,400 stars, Apache 2.0. Project home: agent-memory.dev.

The problem it solves

Re-explaining the architecture to the agent every session
Rediscovering the same bug
Re-teaching the same preferences (library choices, code style)
Built-in memory like CLAUDE.md or .cursorrules is capped at 200 lines and goes stale fast

How it works

The agent silently captures what it does → compresses → stores as searchable memory → injects only the relevant context at the start of the next session. The key trick: stand up a single MCP server and 16+ agents share the same memory.

Supported clients:

Claude Code · Cursor · Gemini CLI · Codex CLI
Cline · Goose · Windsurf · Roo Code · OpenCode
Any agent without MCP can connect via REST (104 endpoints)

Embeddings run locally with all-MiniLM-L6-v2 — no API keys, free.

Benchmark — LongMemEval-S

Numbers on LongMemEval (ICLR 2025, 500 questions):

Metric	agentmemory	BM25 fallback
R@5	95.2%	86.2%
R@10	98.6%	—
MRR	88.2%	—

Hybrid embedding retrieval beats keyword-only BM25 by 9 percentage points on R@5.

Token cost

Approach	Annual tokens	Annual cost
Full context paste	19.5M+	Exceeds context window
LLM-summarized	~650K	~$500
agentmemory	~170K	~$10
agentmemory + local embeddings	~170K	$0

Quick start

npx @agentmemory/agentmemory

What it really argues

The bet underneath agentmemory is one sentence — “memory belongs in the infrastructure layer, not the agent.” Instead of every agent writing its own memory, one MCP server fans out to all of them. Whatever Claude Code learns flows into the next Cursor session intact. The project started about 50 days earlier as a viral GitHub gist (1,050 stars) and is essentially that design doc rendered into code: Karpathy’s LLM Wiki pattern plus confidence scoring, lifecycle, knowledge graph, and hybrid search.

2. agent-skills — Senior-Engineer Workflow as a Skill Bundle

addyosmani/agent-skills calls itself “Production-grade engineering skills for AI coding agents.” Created 2026-02-15, ~33,500 stars, MIT. At the same point in time it has 14× the stars of agentmemory — currently the strongest candidate for an agent-workflow standard.

The problem it solves

“The agent writes code, but it doesn’t write code like a senior would.”

Skips the spec
Skips the tests
Doesn’t think about security
Drops a giant PR all at once

A six-stage lifecycle

DEFINE → PLAN → BUILD → VERIFY → REVIEW → SHIP
/spec /plan /build /test /review /ship

Each slash command corresponds to one lifecycle stage and auto-activates the right skills.

The 20 skills, by stage

Define: idea-refine, spec-driven-development
Plan: planning-and-task-breakdown
Build: incremental-implementation, test-driven-development, context-engineering, source-driven-development, frontend-ui-engineering, api-and-interface-design
Verify: browser-testing-with-devtools, debugging-and-error-recovery
Review: code-review-and-quality, code-simplification, security-and-hardening, performance-optimization
Ship: git-workflow-and-versioning, ci-cd-and-automation, deprecation-and-migration, documentation-and-adrs, shipping-and-launch

Where it runs

Claude Code (recommended, marketplace-installed): /plugin marketplace add addyosmani/agent-skills
Cursor: copy SKILL.md into .cursor/rules/
Gemini CLI · Windsurf · OpenCode · GitHub Copilot · Kiro IDE · Codex — anything that reads Markdown works

Agent personas

code-reviewer — Senior staff engineer lens, “would a staff engineer approve this?”
test-engineer — QA discipline, the Prove-It pattern
security-auditor — OWASP, threat modeling

What it really argues

agent-skills’ bet is “the difference between agents isn’t model weight — it’s how strictly the workflow is enforced.” TDD here isn’t “you can do TDD” — it’s “no Red-Green-Refactor, no code.” Code review isn’t a vibe; it’s five-axis review, 100-line size limits, explicit Nit/Optional/FYI severity labels. By expressing all of this in Markdown, it stays agent-agnostic — the same skill bundle works in Claude, Cursor, and Gemini. 33K stars is the market saying this is the closest thing to a workflow standard right now.

3. Side by side

Dimension	agentmemory	agent-skills
Author	rohitg00	addyosmani
Form	TypeScript library + MCP server	Markdown skill bundle
License	Apache 2.0	MIT
Stars (2026-05)	~2,400	~33,500
Created	2026-02-25	2026-02-15
Domain	Memory / state infrastructure	Engineering workflow
Decoupling mechanism	MCP standard	Markdown standard

4. The Combined Picture — An OS Layer for Agents

flowchart LR
 M["Memory / state"] --> AM["agentmemory"]
 W["Workflow / rules"] --> AS["agent-skills"]
 Mo["Model"] --> LLM["Claude / GPT / Gemini"]
 UI["UI"] --> Tools["Claude Code / Cursor / Cline"]

Three or four years ago “which IDE do you use?” was the deciding question. Now it’s becoming “what’s your memory and skills setup?” Both projects deliberately decouple from any one model — MCP for one, plain Markdown for the other — designed so that models can be swapped, but the memory and skills accumulate.

5. The Skills Ecosystem Is Crystallizing — Four More Repos in the Same Direction

Two days after the original post, four more repositories that surfaced shortly after make the same point from different angles. First, hesreallyhim/awesome-claude-code (~43K stars, created 2025-04, an awesome-list) curates skills, hooks, slash-commands, agent orchestrators, and plugins in one place — the fact that “Claude Code ecosystem” now stands on its own as an awesome-list category is itself a maturity signal. Second, well-known TypeScript educator Matt Pocock has open-sourced his actual .claude/ directory as mattpocock/skills (~69K stars, “Skills for Real Engineers, straight from my .claude directory”); he explicitly rejects heavy process frameworks like GSD, BMAD, and Spec-Kit because they “take away your control,” and instead picks small composable skills — /grill-me, /tdd, /diagnose — that exactly match the “Markdown standard” bet this post described.

Third, SuperClaude-Org/SuperClaude_Framework (~22.7K stars, MIT, project site) bundles 30 slash commands, 20 specialized agents, 7 behavioral modes, and 8 MCP servers to “transform Claude Code into a structured development platform” — essentially a more opinionated extension of addyosmani’s six-stage lifecycle. Fourth, forrestchang/andrej-karpathy-skills (~123K stars) distills Andrej Karpathy’s tweet on LLM coding pitfalls into a single CLAUDE.md with four principles (Think Before Coding, Simplicity First, Surgical Changes, Goal-Driven Execution) — a direct descendant of the “Karpathy LLM Wiki pattern” cited in the original post. An awesome-list that stands on its own as a category, an individual senior open-sourcing his skills directory verbatim, a heavy framework wrapping 30 slash commands, and a 100K-star repo condensing one coding luminary’s principles into a single file — that all four arrive within three days is direct evidence that the argument this blog made on 2026-05-08 — workflow belongs in the infrastructure layer — is calcifying into consensus. It is no longer one 33K-star agent-skills, but five repositories stacked on the same bet, converging at the same time.

Insights

The headline of this digest isn’t either tool individually — it’s that two links shared 30 seconds apart fill exactly two distinct slots in the agent OS layer. agentmemory pulls state down into the infrastructure; agent-skills pulls process down into the infrastructure. The fact that both decouple from models in similar ways — one MCP server, one Markdown bundle — is the same bet from two angles: models are interchangeable but memory and skills must compound. The 33K vs 2.4K stars gap probably isn’t about timing; it’s a signal that the workflow-standard candidate is consolidating faster than the memory-infrastructure candidate. Two open questions for next quarter — does memory standardize on MCP, and do skill bundles like agent-skills become a new SaaS category inside IDE marketplaces? The decision point has already started shifting from IDE choice to memory and skill setup.

References

Core repos

rohitg00/agentmemory · home: agent-memory.dev
addyosmani/agent-skills

Skills collections (2026-05-10 update)

hesreallyhim/awesome-claude-code — awesome-list for Claude Code resources (~43K stars)
mattpocock/skills — Matt Pocock’s .claude/ directory, “Skills for Real Engineers” (~69K stars)
SuperClaude-Org/SuperClaude_Framework — 30 commands + 20 agents + 8 MCP servers (~22.7K stars)
forrestchang/andrej-karpathy-skills — Karpathy’s four principles in one CLAUDE.md (~123K stars)

Related agents and clients

Claude Code · Cursor · Cline · Windsurf
Gemini CLI · Codex · OpenCode · Goose · Roo Code
GitHub Copilot · Kiro IDE

Protocols and standards

Model Context Protocol (MCP)
OWASP — basis for the security-auditor persona

Benchmarks and embeddings

Paper: LongMemEval (arXiv:2410.10813, ICLR 2025)
sentence-transformers/all-MiniLM-L6-v2 — local embedding model used by agentmemory