Skills Library

A curated collection of 1,451 skills for AI coding agents (OpenCode, Claude Code, and compatible). Each skill is an instruction file that tells an AI agent how to perform a specific task with expert-level depth — not just what to do, but exactly how, with what checks, in what order.

GitHub Repository

---

Table of Contents

• 1. What Is a Skill?
• 2. What's Inside
• 3. Quick Start (For Humans)
• 4. The LLM Workflow (For AI Agents)
• 5. Catalog Files Reference
• 6. Project Structure
• 7. Adding New Skills
• 8. Updating & Maintenance
• 9. Use Cases & Examples
• 10. FAQ

---

1. What Is a Skill?

A skill is a SKILL.md file with:

---
name: code-reviewer
aliases: [code-reviewer]
description: "Elite code review across 10+ domains"
risk: unknown
source: community
---

## Instructions
- Check for security vulnerabilities
- Verify error handling
- Review test coverage
- ...

When you ask an agent to "review this code" without a skill — it responds with generic, surface-level advice.

When the agent loads the code-reviewer skill — it follows an expert checklist: security scanning, performance analysis, edge case validation, architectural review, test coverage assessment, and more.

Skills turn a general-purpose AI into a domain expert.

---

2. What's Inside

Metric	Value
Total skills	1,451
Categories	75
Tier: core (⭐ verified)	54
Tier: library (standard)	1,387
Tier: draft (⚠️ sparse)	10
Sources tracked	96
Catalog formats	5 (MD tables, MD index, JSON, CSV, Obsidian vault)
Skill packs	6 (packs/)
Skill file size	100 bytes – 100 KB each
Git repo	Yes, on GitHub

Skill Categories (75)

Agent Behavior · Agent Orchestration · AI Agents · AI/ML · AI Research · AI Testing · Andruia · API Integration · App Builder · Architecture · Automation · Backend · Blockchain · Browser Automation · Business · Business Strategy · Cloud · Code · Code Quality · Coding · Collaboration · Content · Core Dev · Data · Data AI · Data Engineering · Data Science · Database · Database Processing · Design · Developer Tools · Development · Development & Testing · DevOps · Document Processing · Ecommerce · Education · Finance · Framework · Front-End · Frontend · Game Development · Granular Workflow Bundle · Graphics Processing · Growth · Health · Legal · Leiloeiro · Marketing · MCP · Media · Memory · Meta · Mobile · Personal Development · Planning · Presentation Processing · Product Management · Productivity · Project Management · Prompt Engineering · Reliability · Research · Science · Security · Spreadsheet Processing · Test Automation · Testing · Tool Quality · Uncategorized · Voice Agents · Web Development · Workflow · Workflow Bundle · Writing

---

Quality Tiers

Skills are automatically scored and classified into three tiers:

| Tier | Label | Count | Criteria | |---|---|---|---|---| | Elite | [elite] | 10 | Manually curated — best of the best, proven value | | Core | [core] | 44 | Automated score ≥ 13: detailed instructions, rich content, resources | | Library | — | 1,387 | Standard community quality | | Draft | — | 10 deleted | Empty template stubs — removed |

The SKILLS_INDEX.md marks core skills with [core] and draft skills with [draft]. When an AI agent scans the catalog, it automatically prioritizes core skills.

Elite Skills (Top 10)

Manually selected skills that provide the highest value for AI-assisted development:

Skill	Category	What It Does
007	security	Universal security audit: STRIDE/PASTA, OWASP, Red/Blue Team, code review
architecture-decision-records	architecture	Documents WHY decisions were made — not just what
conductor-implement	workflow	Structured TDD implementation from specs
context-driven-development	ai-ml	Manages AI context as a code artifact
dependency-upgrade	development	Safe major version upgrades with compatibility analysis
grpc-golang	development	Production-grade gRPC services in Go
postmortem-writing	reliability	Blameless postmortems that drive organizational learning
semgrep-rule-variant-creator	security	Port security rules between languages automatically
senior-frontend	web-development	Comprehensive React/Next.js/TypeScript standards
temporal-golang-pro	workflow	Durable distributed systems with Temporal Go SDK

# Install all elite skills at once
skill-get 007
skill-get architecture-decision-records
skill-get conductor-implement
skill-get context-driven-development
skill-get dependency-upgrade
skill-get grpc-golang
skill-get postmortem-writing
skill-get semgrep-rule-variant-creator
skill-get senior-frontend
skill-get temporal-golang-pro

Skill Packs

Pre-built collections for common roles in packs/:

Pack	Skills	Role
fullstack-developer.txt	10	Code review, debugging, architecture, planning
security-engineer.txt	10	Security audit, pentesting, vulnerability scanning
devops.txt	11	Docker, K8s, Terraform, monitoring, CI/CD
ai-engineer.txt	10	LLM apps, RAG, vector DBs, prompt engineering
data-scientist.txt	10	SQL, pandas, polars, visualization, ML
productivity.txt	10	Core workflow skills for daily development

Install a pack: xargs skill-get < packs/fullstack-developer.txt

---

3. Quick Start (For Humans)

Prerequisites

• macOS or Linux
• Git (git --version)
• An AI agent that supports skills (OpenCode, Claude Code)

Clone the Repository

git clone --depth=1 git@github.com:VasilevNStas/skills-library.git ~/.local/share/skills-library

Install the Installer

cp ~/.local/share/skills-library/install.sh ~/.local/bin/skill-get
chmod +x ~/.local/bin/skill-get

Install a Skill Into Your Project

cd /path/to/your/project
skill-get using-superpowers      # Installs → .opencode/skills/using-superpowers/SKILL.md
skill-get code-reviewer
skill-get debugging-strategies

Browse the Catalog

skill-get --list              # Show all categories with skill counts
skill-get --search security   # Find skills about security
skill-get --info code-reviewer  # Show details without installing

Install Multiple Skills at Once

cat skills.txt | xargs -I{} skill-get {}

Use the AGENTS.md Template

Copy AGENTS.md from the project root into your own project's config. It contains the ready-to-use LLM auto-selection protocol. The agent will scan SKILLS_INDEX.md, find the right skill, load it, and follow its instructions.

Open as Obsidian Vault

Open ~/.local/share/skills-library/ in Obsidian. Every skill is searchable via [[skill-name]] wikilinks. The SOURCES.md file is your entry point.

---

4. The LLM Workflow (For AI Agents)

This is the core innovation of this project: an automated skill selection loop that lets any AI agent act as a skill-powered expert.

The Problem

You have 1,451 skills across 75 categories. How does an agent know which one to use for a given task?

The Solution

Give the agent SKILLS_INDEX.md as background context. The agent will:

1. Parse the user's request
2. Scan the catalog for matching skills
3. Select the best fit
4. Load the skill file
5. Execute following the skill's instructions

The Algorithm

User: "Review this Pull Request"
  │
  ▼
Agent scans SKILLS_INDEX.md (provided as context)
  │
  ├─ Finds: [[code-reviewer]] | development | Elite code review across 10+ domains
  ├─ Finds: [[security-auditor]] | security | DevSecOps audit
  ├─ Finds: [[code-quality/comprehensive-review-full-review]] | code-quality | Full review
  │
  ▼
Agent selects the most relevant skill(s)
  │
  ▼
Agent loads the skill file (Skill tool / Read tool)
  │
  ▼
Agent follows the skill's step-by-step instructions
  │
  ▼
Agent produces expert-level output

Practical Setup

The project ships with a ready-to-use AGENTS.md file. Copy it to your project:

cp ~/.local/share/skills-library/AGENTS.md ./AGENTS.md

It implements the complete protocol:

## Skill Auto-Selection Protocol
1. Read `~/.local/share/skills-library/SKILLS_INDEX.md`
2. Match task → skill by domain and description
3. Prioritize `tier: core` skills for critical tasks
4. Load the skill file and follow instructions precisely
5. Combine multiple skills for multi-domain tasks

Prompt Template for Quick Reference

When starting a conversation, you can say:

"I have a skills library at ~/.local/share/skills-library/. Read SKILLS_INDEX.md first to find the right skill for this task, then load it and follow its instructions."

Why This Works

• Skills are self-documenting — each SKILL.md describes its purpose
• The index is compact — 1,451 skills in 1,630 lines, fits in context easily
• LLMs are good at classification — matching a task to a skill is a natural fit
• Skill instructions are executable — the agent follows them like a recipe

---

5. Catalog Files Reference

File	Format	Lines	Purpose
SKILLS.md	MD tables	~1,886	Master index by category (human-readable)
SOURCES.md	MD with TOC	~3,213	Skills organized by origin (96 sources)
SKILLS_INDEX.md	MD flat list	~1,630	LLM-optimized: 1 skill/line, alphabetical
SKILLS_INDEX.json	JSON	1,451 items	Machine-readable: structured API
INVENTORY.csv	CSV	1,451 rows	Spreadsheet: all metadata fields

When to Use Each

• Browse by category → SKILLS.md
• Find skill origin → SOURCES.md
• Feed to an LLM → SKILLS_INDEX.md
• Programmatic search → SKILLS_INDEX.json
• Filter in Excel/Sheets → INVENTORY.csv

---

6. Project Structure

~/.local/share/skills-library/
│
├── libraries/                          # All skills (source of truth)
│   ├── development/                    # Category directory
│   │   ├── code-reviewer/              # Skill directory
│   │   │   └── SKILL.md               # The skill itself
│   │   ├── ...
│   ├── security/
│   ├── ai-ml/
│   ├── {category}-category-pointer/    # Obsidian MOC files
│   └── ... (75 categories)
│
├── SKILLS.md                           # Master index (by category)
├── SOURCES.md                          # Skills by origin (96 sources)
├── SKILLS_INDEX.md                     # LLM-optimized index
├── SKILLS_INDEX.json                   # JSON catalog
├── INVENTORY.csv                       # CSV catalog
├── README.md                           # This file
├── install.sh                          # Standalone install script
│
├── scripts/
│   └── update-sources.py               # Regenerates SOURCES.md + INVENTORY.csv
│
└── .gitignore

Each skill directory is self-contained:

libraries/development/code-reviewer/
├── SKILL.md              # Required — the skill instructions
└── resources/            # Optional — supporting files, templates, examples
    └── implementation-playbook.md

---

7. Adding New Skills

From a Known Source

1. Clone the source repository
2. Copy the skill directory into the correct category:

   cp -r /path/to/source-repo/skills/my-skill libraries/{category}/my-skill/

3. Add the source URL to the source: field in SKILL.md
4. Run the update script:

   python3 scripts/update-sources.py

5. Add an entry to SKILLS.md (in the appropriate category table)
6. Commit and push

Creating a New Skill From Scratch

mkdir -p libraries/my-category/my-skill

Create SKILL.md:

---
name: my-skill
aliases: [my-skill]
description: "What this skill does and when to use it"
risk: unknown
source: self
---

## Use this skill when
- Describe the exact conditions for using this skill

## Instructions
- Step-by-step instructions for the agent
- Specific checks, validations, and outputs

Guidelines

• Every skill must have a name:, description:, source:, and aliases: in frontmatter
• The description: should clearly state when to use this skill
• Keep instructions actionable — the agent will follow them literally
• Use aliases: [skill-name] for Obsidian compatibility
• After adding, regenerate the indexes: python3 scripts/update-sources.py

---

8. Updating & Maintenance

Regenerate All Indexes

cd ~/.local/share/skills-library
python3 scripts/update-sources.py    # Updates SOURCES.md + INVENTORY.csv
# SKILLS_INDEX.md and SKILLS_INDEX.json are generated separately

Sync to GitHub

cd ~/.local/share/skills-library
git add -A
git commit -m "Describe your changes"
git push

Sync to a New Machine

git clone --depth=1 git@github.com:VasilevNStas/skills-library.git ~/.local/share/skills-library
cp ~/.local/share/skills-library/install.sh ~/.local/bin/skill-get

Check Integrity

cd ~/.local/share/skills-library && python3 -c "
import glob
# Verify all categories in SKILLS.md match disk
import re
with open('SKILLS.md') as f:
    content = f.read()
sections = re.split(r'\n(?=^## [a-z][a-z0-9_-]+ *\()', content, flags=re.MULTILINE)
for sec in sections:
    m = re.match(r'^## +([a-z][a-z0-9_-]+) *\(([0-9]+) +скилл', sec)
    if m:
        cat, claimed = m.group(1), int(m.group(2))
        actual = len(glob.glob(f'libraries/{cat}/*/SKILL.md'))
        if claimed != actual:
            print(f'❌ {cat}: {claimed} claimed, {actual} on disk')
print('Done')
"

---

9. Use Cases & Examples

Code Review (development/code-reviewer)

You: "Review the authentication module in src/auth/"
Agent (scans index → finds code-reviewer → loads skill):
  → Security: SQL injection, XSS, CSRF
  → Error handling: proper error propagation
  → Testing: coverage gaps
  → Performance: N+1 queries, caching
  → Architecture: coupling, cohesion

Security Audit (security/security-auditor)

You: "Audit this repo for security issues"
Agent (scans index → finds security-auditor → loads skill):
  → Dependency scan
  → SAST analysis
  → Secret detection
  → OWASP Top 10 checklist
  → Hardening recommendations

Debugging (development-and-testing/debugging-strategies)

You: "The production API is returning 500 errors"
Agent (scans index → finds debugging-strategies → loads skill):
  → Structured debugging protocol
  → Log analysis patterns
  → Root cause isolation
  → Fix verification

Research (ai-ml/deep-research)

You: "Research the latest advances in RAG architectures"
Agent (scans index → finds deep-research → loads skill):
  → Plan research approach
  → Search and gather sources
  → Synthesize findings
  → Produce structured report

---

10. FAQ

Q: Do I need all 1,451 skills? A: No. Install only the ones you need into your project. The library is a curated collection — pick and choose.

Q: How do I find the right skill? A: Use skill-get --list, skill-get --search <keyword>, or browse SKILLS.md. For automated selection, give SKILLS_INDEX.md to your AI agent.

Q: Can I use this with any AI agent? A: Any agent that supports loading SKILL.md files (OpenCode, Claude Code, Cline, etc.).

Q: The skill references resources/implementation-playbook.md — where is it? A: Some skills have it, some don't. Skills that have the file ship with it in their resources/ directory. If a skill references it but doesn't have it, the reference was replaced with a generic prompt.

Q: How do I update a skill? A: Edit the SKILL.md directly in libraries/{category}/{skill}/. It's a Git repo — commit and push your changes.

Q: Can I contribute skills? A: Yes. Add your skill to the appropriate category, set source: to your repository URL, and submit a PR (once the repo is public).

Q: Why is the project so large (1,451 skills)? A: Skills are small text files (100 bytes – 100 KB each). The entire library is under 50 MB. Most of the size comes from 75 category directories and the index files.

---

Generated and maintained by VasilevNStas. Last updated: 2026-05-25.