Overview

Claude Code skills are reusable prompt definitions stored as markdown files in .claude/commands/, making them available as slash commands in any Claude Code session. The community has converged on a library of shared skills covering everything from project scaffolding to end-of-session retrospectives. Skills are plain text; they can be version-controlled, shared, installed from GitHub, and composed into multi-skill workflows.

The two most widely adopted community skills are GSD (Get-Shit-Done) for large iterative projects and Superpowers for small-to-medium, well-defined work. Beyond these, a growing ecosystem covers specialised domains: security auditing, multi-agent orchestration, session context management, credential handling, and domain-specific workflows.

Top community picks

Ranked by upvotes in the r/ClaudeAI community thread (most voted first):

# Skill Best for Repo
1 GSD (Get-Shit-Done) Large, iterative projects with many phases github.com/gsd-build/get-shit-done
2 Superpowers Small-medium, well-defined projects; brainstorming github.com/obra/superpowers
3 Meta-skill (self-improving) Autonomously improves your other skills over time github.com/rebelytics/one-skill-to-rule-them-all
4 /close End-of-session context persistence; memory + git (prompt-only, see below)
5 tonone Multi-agent team with 23 specialist agents github.com/tonone-ai/tonone
6 LLM wiki Karpathy wiki pattern as a Claude Code skill github.com/6eanut/llm-wiki
7 LLM Council Multi-model decisions; creative friction github.com/karpathy/llm-council
8 authsome Credential management; authenticated API calls github.com/agentrhq/authsome

Notable also-rans: OpenSpec (quick iteration), grill-me (Socratic design review), Supabase Sentinel (security audit), Cabinet (repo-audit + handoff), Session 0 (project bootstrapping), Dendrite (biomimetic debugging), interactive-educator, PraxisKit (kanban for multi-agent workflows).

Project-scope skill frameworks

GSD (Get-Shit-Done)

Superpowers

When to choose which

Criterion GSD Superpowers
Project size Large, many iterations Small-medium, well-defined
End state Unknown at start Known from the start
Speed Slower, methodical Faster
Safety Many checkpoints Fewer, more efficient
Brainstorming Adequate Excellent

Multi-agent team skill (tonone)

tonone ships 23 specialist agents as a team, each owning a domain:

Skills become agent-specific slash commands rather than one-size-fits-all: /spine-review (API surface, performance, distributed systems), /warden-audit (IAM, secrets, compliance), /proof-strategy (test coverage, E2E plan). Each agent runs in its own git worktree so parallel work does not conflict.

Repo: https://github.com/tonone-ai/tonone (MIT licensed)

Key principle: domain ownership beats task-based parallelism. Agent context is scoped to its domain so it does not dilute across unrelated concerns.

Credential management skill

authsome manages credentials for GitHub, Google, OpenAI, Anthropic, Linear, Slack, Notion, Resend, SendGrid, and others. Claude can make authenticated API calls without raw secrets ever entering the chat; the agent never holds the raw secret.

Setup: alias authsome="uvx authsome@latest". After that, Claude picks up the skill and runs the list → login → run workflow on its own.

Repo: https://github.com/agentrhq/authsome

Security and auditing skills

Session management skill (/close)

The /close skill is a session-ending command that mechanises context persistence in three phases:

  1. Retrospective — scans session context for decisions, learnings, open tasks, and references; writes typed memory files (user_*.md, feedback_*.md, project_*.md, reference_*.md) and updates MEMORY.md.
  2. Housekeeping — checks git status, generates a commit message, asks before committing, and prepends a new entry to SESSION_LOG.md.
  3. Close — prints a rename suggestion for the session tab and a one-line summary of counters (thoughts captured, memory files updated, commits made).

Community verdict: “context persistence across sessions is the real unlock before you start chasing autonomous skill tuning.” Foundational and simpler to get right than self-improving agents.

A simpler variant: maintain a decisions.md file updated at the end of each session with what changed and why — especially valuable when picking up a project after weeks away.

See Session context persistence for the full three-phase implementation and memory file taxonomy.

Skill design patterns

Validators and hard stops over natural language

The most useful parts of a skill are not the natural language instructions — they are the validators, hard stops, and accompanying scripts. One practitioner reports a narrated video production skill that is 60% validation, gates, and encoding scripts, and 40% actual prompting.

Cross-runtime peer review

Claude builds, Codex reviews. Different model, different context, different failure modes. The creative friction between the two catches things neither would catch alone. Especially effective for document writing and code development.

Write your own

If you know exactly what you want from a workflow, writing a custom skill outperforms adopting a 200-line community skill. Community skills are good sources of patterns to steal — not necessarily things to copy wholesale.

Pre-flight principle

Before declaring a skill output done, re-read the skill’s own rules and check the output against them. Makes explicit what is usually implicit, catching “skill says no comments, generated skill has comments” class of failure.

Socratic design-review skill (grill-me)

Matt Pocock’s grill-me skill implements Socratic questioning as a slash command: the model interviews the user relentlessly about a plan, walks every branch of the decision tree one question at a time, and provides its own recommended answer to each question. Terminates at “shared understanding” rather than a fixed question count. If any question can be resolved by inspecting the codebase, the model does so rather than burdening the user with recall.

Repo: https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md

Key design choices:

Resources