DEV Community: Samuel Rose

SKILL.md vs .cursorrules: Agent Instruction Formats Compared

Samuel Rose — Tue, 21 Apr 2026 09:43:28 +0000

If you're teaching an AI coding agent how to work the way your team works, you're choosing between two formats: SKILL.md (used by Claude Code, Codex CLI, OpenClaw, and others) and Cursor's rules system (.cursorrules and .cursor/rules/*.mdc). Both solve the same core problem, but they take different approaches with real implications for portability and flexibility.

This guide breaks down how each works, where each wins, and which to choose for your team.

The short answer

SKILL.md is a portable open standard. A skill is a folder containing a SKILL.md file with YAML frontmatter (name, description, optional fields) and markdown instructions. Skills are loaded on demand. The agent decides whether a skill applies to the current task based on its description, and only loads the full instructions when relevant.

Cursor rules are Cursor-specific configuration. Two main formats: .cursorrules is a single root-level file that applies to every interaction in the project. .cursor/rules/*.mdc is a newer format supporting YAML frontmatter for scoping rules to specific file types or tasks. Rules can be always-on or conditionally loaded.

Pick SKILL.md if you want portability across multiple AI tools or you're building reusable workflows. Pick Cursor rules if you're committed to Cursor and want native integration.

Worth noting: as of Cursor 2.3+, Cursor can also read SKILL.md files from .cursor/skills/ directories and load them as skills. The lines between the two formats are blurring.

Side-by-side comparison

Dimension	SKILL.md	Cursor rules
Supported by	Claude Code, Codex CLI, OpenClaw, Cursor (partial), and others	Cursor only (natively)
File location	`~/.claude/skills/<n>/SKILL.md` (personal) or `.claude/skills/` (project)	`.cursorrules` (root) or `.cursor/rules/*.mdc` (newer)
Format	Markdown with YAML frontmatter	Plain text (`.cursorrules`) or Markdown with frontmatter (`.mdc`)
Loading	On demand, agent decides based on description	Always-on (`.cursorrules`) or conditional via frontmatter (`.mdc`)
Scoping	Via description (semantic match)	Via frontmatter: `alwaysApply`, `globs`, `description`
Structure	Folder with SKILL.md + optional scripts/, references/, assets/	Single file (`.cursorrules`) or folder with multiple `.mdc` files
Ecosystem	Thousands of skills across marketplaces and GitHub	Large community collection, no official marketplace
Portability	High (copy file to another agent's directory)	Low (Cursor-specific)
Precedence	Skills are agent-decided	Rules win when they conflict with skills in Cursor

How SKILL.md works

A SKILL.md file has two parts: YAML frontmatter with metadata, and markdown instructions for the agent.

name: commit-message-writer
description: Use when the user asks for a commit message or to commit changes. Writes conventional commit messages based on the staged diff.
When asked to write a commit message:

Run git diff --staged to see what's changed
Classify the change type (feat, fix, refactor, docs, etc.)
Write a one-line summary under 72 characters
If the change is non-trivial, add a body explaining the why
Use present tense, imperative mood ("Add feature" not "Added feature")

The agent doesn't load this skill into every conversation. It loads the metadata at startup, and when a user's message matches the description, the full skill instructions get loaded. This progressive disclosure keeps context windows efficient.

Skills live in well-known directories by convention:

~/.claude/skills/<n>/SKILL.md — personal skills for Claude Code
.claude/skills/<n>/SKILL.md — project-scoped skills, checked into the repo
~/.openclaw/skills/ — OpenClaw
~/.codex/skills/ — Codex CLI
.cursor/skills/ — Cursor (partial support)

A skill you write for one agent generally works on the others by copying the file to the right directory.

How Cursor rules work

Cursor has two rule formats in active use:

.cursorrules (legacy but still widely used) is a single file at the project root. It applies to every interaction in the project. No frontmatter, no conditional loading. Just instructions the agent always follows.

.cursor/rules/*.mdc (newer) supports multiple rules files, each with YAML frontmatter controlling when the rule applies.

description: TypeScript-specific conventions for this project
globs: "/.ts,/.tsx"
alwaysApply: false

Prefer named exports over default exports
Use strict null checks; no non-null assertions
Document exported functions with TSDoc

The globs and alwaysApply fields give you explicit control over when a rule loads. Without them, the agent uses the description to decide if the rule is relevant to the current task. That's less reliable than the explicit frontmatter controls.

Where SKILL.md wins

Portability across tools. If you write a skill for Claude Code, it works on Codex CLI and OpenClaw by copying the file. For teams that use multiple agents or might switch tools in the future, this portability is valuable. Cursor rules are Cursor-specific.

On-demand loading by default. Skills load only when the agent determines the description matches the task. This keeps every conversation's context window clean and focused.

Larger ecosystem. SKILL.md has the largest ecosystem of portable skills today. Anthropic's official marketplace, community marketplaces like Agensi with security scanning and curation, and thousands of skills on GitHub via the filename:SKILL.md search. Cursor rules have a strong community (PatrickJS/awesome-cursorrules is popular) but no centralized marketplace.

Structured skill packages. A skill can be a folder containing scripts, reference docs, and assets alongside the SKILL.md. This makes skills genuinely portable units that include everything the agent needs.

Cross-agent investment. Time invested in writing SKILL.md skills compounds across any compatible agent. If your team uses Claude Code today and Codex tomorrow, skills follow.

Where Cursor rules win

Native Cursor integration. Rules are built into Cursor from the ground up. They're tightly integrated with the agent's decision loop and the IDE's workflow. SKILL.md support in Cursor exists but is less mature.

Simple always-on application. For "this is how we write code in this project" instructions that should apply to every interaction, .cursorrules at the project root is the simplest possible format. Write instructions, save the file, done.

Explicit scoping control. The newer .mdc format gives you explicit control: alwaysApply: true for must-apply rules, globs: "*.tsx" for file-type-specific rules. This is more reliable than SKILL.md's semantic description matching for rules you need the agent to follow consistently.

Better for project conventions. Rules are ideal for encoding team-wide conventions that apply across all work in a project — coding standards, architectural patterns, documentation requirements. These don't benefit from on-demand loading because they apply universally.

The real distinction: rules vs skills

Testing by the community has surfaced a useful mental model for when to use which:

Rules are for always-on conventions. "Use early returns." "Prefer named exports." "Write tests for all new functions." These are instructions the agent should always follow. Rules (especially with alwaysApply: true) guarantee this.

Skills are for on-demand workflows. "When asked for a commit message, do X." "When reviewing a PR, check Y." "When diagnosing environment issues, run Z." These are procedures that apply to specific tasks, not to every interaction.

If you're working in Cursor and have a team convention that should apply always, use a rule. If you have a procedure that should run when invoked, use a skill. Or both — Cursor supports both.

For teams not committed to Cursor, SKILL.md gives you portability for the procedures, and you can encode conventions in a project-scoped SKILL.md that's always-on-by-description.

When rules and skills conflict

If you have a rule and a skill that give contradictory instructions, community testing has shown rules win in Cursor. The agent cites the rule file and ignores the skill. Don't encode the same instruction in both formats with different content — you'll confuse the agent.

When to pick which

Pick SKILL.md if you:

Use Claude Code, Codex CLI, or OpenClaw as your primary agent
Want portability across multiple AI tools
Are building task-specific workflows (commit messages, code review, migrations)
Want access to existing marketplaces (Agensi, Anthropic's official marketplace, community GitHub repos)
Need to package scripts or reference docs alongside instructions

Pick Cursor rules if you:

Use Cursor as your primary (or only) AI coding tool
Need always-on team-wide conventions
Want explicit control over when rules load (via globs, alwaysApply)
Value native integration over portability

Use both if you:

Use Cursor but want to benefit from the SKILL.md ecosystem (Cursor reads SKILL.md from .cursor/skills/)
Have project conventions (rules) plus task-specific workflows (skills)

The verdict

SKILL.md is the portable open standard. Cursor rules are a native, Cursor-specific system with excellent always-on behavior. If portability matters, SKILL.md wins. If you're committed to Cursor and want maximum native integration, rules win. Many teams end up using both — rules for conventions, skills for workflows.

The good news: with Cursor now reading SKILL.md files from .cursor/skills/, the choice isn't permanent. You can start with rules and add SKILL.md skills as you build out your workflow automation, keeping the portability door open.

Browse curated SKILL.md skills at Agensi. All skills work across Claude Code, OpenClaw, Cursor, Codex CLI, and other compatible agents.

The 10 Best Skills for Claude Code in 2026

Samuel Rose — Sat, 28 Mar 2026 11:01:57 +0000

The Claude Code skills ecosystem has grown fast. Between the official Anthropic marketplace, community GitHub repos, and curated marketplaces like Agensi, there are now thousands of skills available. The problem isn't finding skills anymore. It's knowing which ones are actually worth installing.

We tested dozens of skills across different categories and picked the 10 that deliver the most value in real, everyday development work. Some are free, some are paid. All of them earned their spot by doing one thing well.

1. git-commit-writer

What it does: Analyzes your staged git changes and writes a conventional commit message. It detects the commit type (feat, fix, refactor, docs, chore), identifies the scope from changed files, and flags breaking changes. If you've staged multiple logical changes, it suggests splitting them into separate commits.

Why it's on this list: Writing good commit messages is one of those tasks that's easy to skip and painful to catch up on later. This skill turns a five-minute chore into a two-second confirmation. The messages it produces follow the Conventional Commits spec, which means they work with tools like semantic-release and standard-version.

Best for: Any developer who touches git daily.

Get git-commit-writer on Agensi (Free)

2. code-reviewer

What it does: Runs a structured code review on your recent changes. It checks for security vulnerabilities (SQL injection, XSS, authentication bypasses), logic errors, edge cases, performance issues, and style violations. Findings are organized by severity: Critical, Warning, and Suggestion.

Why it's on this list: Human code review is essential but inconsistent. You catch different things depending on how tired you are and how familiar you are with the code. This skill applies the same thorough checklist every time. It's not a replacement for peer review, but it's an excellent first pass that catches the obvious stuff before a human looks at it.

Best for: Solo developers who don't have a teammate to review their code, and teams who want a consistent baseline.

Get code-reviewer on Agensi (Free)

3. pr-description-writer

What it does: Reads your branch diff against the base branch and writes a complete pull request description. It covers what changed, why it changed, how it was implemented, and what reviewers should test. Supports GitHub, GitLab, and Bitbucket formatting.

Why it's on this list: Most PR descriptions are either empty or say "fixes stuff." This skill produces descriptions that actually help reviewers understand the context, which means faster reviews and fewer back-and-forth comments. It reads the actual code changes, so the description is always accurate to what was done.

Best for: Teams that care about PR quality and reviewers who are tired of asking "what does this do?"

Get pr-description-writer on Agensi (Free)

4. env-doctor

What it does: Systematically diagnoses why your project won't start. It checks runtime versions (Node, Python, Ruby, etc.), missing dependencies, environment variables, database connections, port conflicts, and build artifacts. It works through issues in a logical order instead of throwing errors at you one at a time.

Why it's on this list: "It works on my machine" is still one of the most common developer problems. When you clone a repo or switch branches and something breaks, the first 20 minutes are usually wasted guessing. This skill does the detective work for you and tells you exactly what's wrong and how to fix it.

Best for: Developers who work across multiple projects, onboard to new repos frequently, or just hate debugging environment issues.

Get env-doctor on Agensi (Free)

5. readme-generator

What it does: Scans your project structure, reads your package files and dependencies, checks for configuration files, and generates a complete README.md. The output includes a project description, installation instructions, usage examples, tech stack overview, and contribution guidelines. All based on what's actually in the repo, not boilerplate.

Why it's on this list: A good README is the front door to your project, but writing one from scratch is tedious. This skill produces a solid first draft in seconds. You'll still want to edit it, but starting from an accurate, well-structured document is much faster than starting from a blank file.

Best for: Open source maintainers and anyone who's been meaning to write a README but keeps putting it off.

Get readme-generator on Agensi (Free)

6. changelog-generator

What it does: Reads your git history and transforms developer commit messages into user-facing release notes. It groups changes by type (new features, bug fixes, improvements), filters out internal commits that users don't care about, and formats the output as a clean changelog entry.

Why it's on this list: Users want to know what changed. Developers write commits for other developers. This skill bridges that gap by translating technical commit history into plain-language summaries. If you use conventional commits (and you should, see #1), the output is even better.

Best for: Anyone who ships releases and needs to communicate what changed.

Get changelog-generator on Agensi (Free)

7. migration-auditor

What it does: Reviews database migration files before they run in production. It checks for table locking hazards, potential data loss, missing rollback steps, index issues, and unsafe operations. Supports PostgreSQL, MySQL, and SQLite.

Why it's on this list: Bad migrations are one of the most dangerous things you can deploy. They can lock tables, drop data, or cause extended downtime. Most teams rely on manual review to catch these problems, which is error-prone under deadline pressure. This skill catches the dangerous patterns before they reach production.

Best for: Backend developers and DBAs who write or review migrations.

Get migration-auditor on Agensi

8. Anthropic's frontend-design skill

What it does: This is an official Anthropic skill that gives Claude a design system and philosophy before it writes any frontend code. Instead of producing the same generic layout every time (Inter font, purple gradient, grid cards), it pushes Claude toward distinctive typography, purposeful color choices, and intentional animations.

Why it's on this list: If you've used Claude to build UIs, you know they all start to look the same. This skill breaks that pattern. It's one of the most popular skills in the ecosystem for a reason, with hundreds of thousands of installs since launch.

Best for: Developers building frontends with Claude who want results that don't look AI-generated.

Available through the Claude Code plugin marketplace: /plugin install

9. Anthropic's /simplify skill

What it does: This is a bundled Claude Code skill (built in, no install needed). After you implement a feature or fix a bug, run /simplify and it spawns three parallel review agents that check for code reuse opportunities, code quality issues, and efficiency improvements. It aggregates findings and applies fixes.

Why it's on this list: It's like having three reviewers look at your work simultaneously, each with a different focus. The parallel execution means it's fast, and because it runs after you're "done," it catches the shortcuts and quick fixes you made under pressure.

Best for: Every Claude Code user. It's free and built in. Just type /simplify after finishing a task.

No install needed. Type /simplify in any Claude Code session.

10. Anthropic's /batch skill

What it does: Another bundled skill. Give it a natural language instruction and it orchestrates large-scale changes across your entire codebase in parallel. For example: "Add error handling to all API endpoints" or "Update all test files to use the new assertion syntax."

Why it's on this list: Some changes touch dozens or hundreds of files. Doing them one at a time is slow, even with Claude. The /batch skill parallelizes the work across multiple agents, each handling a subset of files. It's the closest thing to having a team of developers execute a refactor simultaneously.

Best for: Large codebases and sweeping refactors.

No install needed. Type /batch followed by your instruction in any Claude Code session.

How to install these skills

For Agensi skills (1-7), download the zip from the skill page and extract it:

unzip skill-name.zip -d ~/.claude/skills/

For the official Anthropic skills (8), use the plugin marketplace:

/plugin install

For the bundled skills (9-10), they're already part of Claude Code. Just type the command.

For a detailed walkthrough of all installation methods, see our guide: How to Install Skills in Claude Code.

What we looked for

We evaluated skills on five criteria:

Immediate usefulness. Does it solve a problem you face every day, or is it a nice-to-have that you'll forget about?

Output quality. Are the results accurate, well-formatted, and actually usable without heavy editing?

Reliability. Does it work consistently across different projects and codebases, or does it break on edge cases?

Simplicity. Can you start using it in under a minute, or does it require configuration and setup?

Compatibility. Does it work across multiple agents (Claude Code, OpenClaw, Codex CLI, Cursor), or is it locked to one tool?

Every skill on this list scored well on all five. Your mileage may vary depending on your stack and workflow, but these are solid starting points for any developer using Claude Code in 2026.

Browse more skills on the Agensi marketplace. All skills work with Claude Code, OpenClaw, and other SKILL.md-compatible agents.

What Is SKILL.md? A Complete Guide to AI Agent Skills

Samuel Rose — Sat, 28 Mar 2026 11:00:47 +0000

If you've been using AI coding agents like Claude Code, OpenClaw, Codex CLI, or Cursor, you've probably seen people talking about "skills" — packaged instructions that make your agent better at specific tasks. At the heart of this ecosystem is a simple file called SKILL.md.

This guide covers everything you need to know: what SKILL.md is, how the format works, how AI agents discover and use skills, and how to get started installing or creating your own.

What is SKILL.md?

SKILL.md is a markdown file that teaches an AI coding agent how to perform a specific task. Think of it like a detailed playbook: it tells the agent what to do, when to do it, and how to do it well.

Each skill is self-contained in a folder. At minimum, that folder contains one file — SKILL.md — with two parts:

YAML frontmatter at the top (between --- markers) that holds metadata like the skill's name, description, and configuration options
Markdown instructions below the frontmatter that the agent follows when the skill is active

A skill can be anything: a code review checklist, a git workflow automation, a documentation generator, a deployment process, or a testing strategy. If you can describe a task clearly enough for a knowledgeable developer to follow, you can turn it into a skill.

The SKILL.md format was introduced by Anthropic for Claude Code and has since been adopted as an open standard. The same skill file works across Claude Code, OpenClaw, OpenAI Codex CLI, Gemini CLI, Cursor, and other AI coding tools that support the format — you write it once and use it everywhere.

How the SKILL.md format works

Here's what a minimal SKILL.md file looks like:

---
name: code-reviewer
description: Reviews code for bugs, security issues, and best practices. 
  Use when the user asks for a code review or mentions reviewing changes.
---

# Code Reviewer

When asked to review code, follow these steps:

1. Read all changed files in the current branch
2. Check for security vulnerabilities (SQL injection, XSS, auth issues)
3. Check for logic errors and edge cases
4. Check for performance problems
5. Suggest improvements with code examples

## Output format

Organize findings by severity: Critical, Warning, Suggestion.
For each finding, show the file, line, issue, and a fix.

The frontmatter tells the agent when to use this skill — the description field is what the agent reads to decide if the skill is relevant to what you're asking it to do. The markdown body tells the agent how to execute the task.

Frontmatter fields

The most common frontmatter fields are:

name — the skill's identifier, which also becomes the /slash-command you can type to invoke it manually. Use lowercase with hyphens.

description — the most important field. This is what the agent reads to decide whether to load the skill automatically. Be specific about trigger phrases and use cases, for example: "Use when the user asks to review code, fix bugs, or mentions PR review."

context — controls how the skill runs. Set to fork if you want it to run as a subagent (isolated context), or leave it unset to run inline (shared context with your conversation).

disable-model-invocation — set to true if you only want the skill to be triggered manually via /skill-name, not automatically by the agent. Good for skills with side effects like deployments or sending messages.

Beyond the basics

Skills can include more than just a SKILL.md file. A typical skill folder might look like this:

my-skill/
├── SKILL.md           # Required — instructions and metadata
├── scripts/           # Optional — helper scripts the skill can run
├── references/        # Optional — additional docs loaded on demand
└── assets/            # Optional — templates, images, config files

The SKILL.md file can reference scripts and supporting files. For instance, a deployment skill might include a bash script that handles the actual deploy, while the SKILL.md provides the decision-making logic around when and how to run it.

How AI agents discover and use skills

When you start a session with Claude Code or another compatible agent, it scans your skills directories and loads the frontmatter from every skill it finds. It doesn't read the full instructions yet — just the names and descriptions.

As you work and make requests, the agent matches your input against skill descriptions. If it finds a relevant skill, it loads the full instructions and follows them. You can also invoke any skill directly by typing /skill-name.

Skills live in one of two locations:

Personal skills at ~/.claude/skills/ — available in every project you work on
Project skills at .claude/skills/ inside a repository — shared with your team through version control

This means a team can commit skills to their repo and every developer using Claude Code on that project gets the same workflows, conventions, and automation automatically.

What can skills do?

Skills are flexible enough to cover almost any developer task. Here are some common categories:

Git and version control — Skills that write commit messages from your staged changes, generate PR descriptions by reading your diff, or produce changelogs from git history. You can find skills like git-commit-writer and pr-description-writer on Agensi.

Code quality and review — Skills that review your code for security issues, logic errors, and style violations. A good code-reviewer skill applies a consistent checklist every time.

Documentation — Skills that generate README files, API documentation, or project wikis by scanning your actual code. The readme-generator skill reads your project structure and dependencies to produce accurate documentation.

DevOps and infrastructure — Skills for deployment automation, environment diagnostics, and migration safety checks. The env-doctor skill diagnoses why your project won't start by systematically checking runtime versions, dependencies, environment variables, and ports.

Testing and QA — Skills that write tests, run test suites, and analyze coverage gaps.

Browse all categories on the Agensi skills page to see what's available.

How to install a skill

Installing a skill takes about 30 seconds. There are three methods:

Method 1: Download from a marketplace

The simplest way. Find a skill on Agensi, download the zip file, and extract it to your skills directory:

# For Claude Code
unzip skill-name.zip -d ~/.claude/skills/

# For OpenClaw
unzip skill-name.zip -d ~/.openclaw/skills/

# For Codex CLI
unzip skill-name.zip -d ~/.codex/skills/

Your agent discovers the skill automatically on the next session. No restart or configuration needed.

Method 2: Clone from GitHub

Many open-source skills live on GitHub. Clone the repo and copy the skill folder:

git clone https://github.com/author/skill-name.git
cp -r skill-name ~/.claude/skills/

Method 3: Plugin marketplace (Claude Code)

Claude Code has a built-in plugin system. Run /plugin in any session to browse and install skills directly from your terminal.

How to create your own skill

Creating a skill is straightforward. You don't need to write code — you need to write clear instructions.

Start by creating a folder in your skills directory:

mkdir -p ~/.claude/skills/my-skill

Then create the SKILL.md file:

---
name: my-skill
description: Describe what this skill does and when the agent 
  should use it. Be specific about trigger phrases.
---

# My Skill

[Write your instructions here. Be specific, use numbered steps, 
and include examples of expected output.]

Test it by starting a new session and asking the agent to do something that matches your skill's description. If the agent doesn't pick it up automatically, try invoking it directly with /my-skill and refine the description field until it triggers reliably.

The open standard

SKILL.md started as Anthropic's format for Claude Code, but it's been published as an open standard called Agent Skills. The goal is portability — a skill written for Claude Code should work with OpenClaw, Codex CLI, Gemini CLI, Cursor, and any other tool that adopts the format.

The ecosystem is growing fast. Marketplaces like Agensi curate reviewed, security-scanned skills you can buy or download for free. GitHub hosts thousands of community-contributed skills. And organizations are building internal skill libraries to standardize workflows across their teams.

Getting started

If you're new to skills, here's what to do:

Install one skill and try it. Pick something immediately useful — git-commit-writer is a good first skill because you'll use it every day.
Browse what's available. Check the Agensi marketplace to see what skills exist across different categories.
Create a simple skill for your own workflow. Think about a task you repeat often and turn it into a skill.
Share it. If your skill works well, submit it to a marketplace or publish it on GitHub.

Browse SKILL.md skills for Claude Code, OpenClaw, and other AI coding agents on the Agensi marketplace.

How to Install Skills in Claude Code: 3 Methods

Samuel Rose — Sat, 28 Mar 2026 10:59:28 +0000

Claude Code becomes a lot more useful once you start adding skills to it. Skills are packaged instructions that teach Claude how to handle specific tasks, from writing commit messages to reviewing code to generating documentation. The good news is that installing them takes less than a minute.

There are three ways to add skills to Claude Code. This guide walks through each method with step-by-step instructions so you can pick whichever fits your workflow.

Before you start

Make sure Claude Code is installed and working. Open your terminal and run:

claude --version

If you get a version number back, you're good. If not, install Claude Code first by following the instructions at claude.ai/install.

Skills are stored in two places:

Personal skills go in ~/.claude/skills/ and are available across all your projects
Project skills go in .claude/skills/ inside a specific repo and are shared with anyone who clones it

Most of the time, you'll install to the personal directory unless you're setting up skills for a team.

Method 1: The plugin marketplace

Claude Code has a built-in plugin system that lets you browse, install, and manage skills without leaving your terminal. This is the fastest method if the skill you want is available as a plugin.

Step 1. Start a Claude Code session in any project:

claude

Step 2. Type /plugin and press Enter. This opens the plugin browser.

Step 3. Navigate to the Discover tab. You'll see a list of available plugins from the default Anthropic marketplace.

Step 4. Find the plugin you want and press Enter to install it. Claude will ask you to choose a scope:

User installs it for all your projects (~/.claude/skills/)
Project installs it for the current repo only (.claude/skills/)

Step 5. That's it. The skill is now active. You can invoke it with /skill-name or let Claude load it automatically when it's relevant.

Adding community marketplaces

The default marketplace only has Anthropic's official plugins. To access community skills, add a third-party marketplace:

/plugin marketplace add author/repository

After adding a marketplace, its plugins show up in the Discover tab alongside the official ones.

Method 2: Manual file install

If a skill isn't available as a plugin, or if you prefer to manage files yourself, you can install skills by copying them into the right directory. This works for skills downloaded as zip files, cloned from GitHub, or created by hand.

Installing from a zip file

Step 1. Download the skill zip file. On Agensi, click the download button on any skill page.

Step 2. Unzip it into your skills directory:

# Personal install (all projects)
unzip code-reviewer.zip -d ~/.claude/skills/

# Project install (current repo only)
unzip code-reviewer.zip -d .claude/skills/

Step 3. Verify the folder structure looks right:

ls ~/.claude/skills/code-reviewer/

You should see at least a SKILL.md file. Some skills also include scripts/, references/, or assets/ folders.

Step 4. Start a new Claude Code session. Claude will automatically detect the new skill.

Installing from GitHub

Step 1. Clone the repository:

git clone https://github.com/author/skill-name.git

Step 2. Copy the skill folder (not the whole repo) to your skills directory:

cp -r skill-name ~/.claude/skills/skill-name

If the repo contains multiple skills in subdirectories, copy just the one you want:

cp -r repo-name/skills/code-reviewer ~/.claude/skills/code-reviewer

Step 3. Start a new session and the skill will be available.

Verifying an install

After installing any skill, you can check that Claude recognizes it. Start a session and type:

/skill-name

If the skill loads, you'll see Claude acknowledge it and follow the skill's instructions. If nothing happens, double check that the SKILL.md file is in the right location and that the folder is directly inside ~/.claude/skills/ (not nested an extra level deep).

Method 3: Download from Agensi

Agensi is a marketplace for curated, security-reviewed SKILL.md skills. Every skill goes through an automated 8-point security scan before it goes live, so you know what you're installing has been inspected.

Step 1. Browse skills at agensi.io/skills. Filter by category, price, or popularity.

Step 2. Click on a skill to see its detail page. Check the description, tags, and security scan results.

Step 3. Click Download (for free skills) or Buy (for paid skills). You'll get a zip file.

Step 4. Unzip into your Claude Code skills directory:

unzip skill-name.zip -d ~/.claude/skills/

Step 5. Start a new Claude Code session. Done.

Agensi skills work with Claude Code out of the box, but most are also compatible with OpenClaw, Codex CLI, Cursor, Gemini CLI, and other agents that support the SKILL.md format.

Managing your installed skills

Over time you'll accumulate skills. Here are a few useful things to know:

List all installed skills:

ls ~/.claude/skills/

Remove a skill: Just delete its folder.

rm -rf ~/.claude/skills/skill-name

Update a skill: Replace the folder with the new version. For GitHub skills, pull the latest changes.

Disable a skill temporarily: Rename the folder to something Claude won't recognize:

mv ~/.claude/skills/code-reviewer ~/.claude/skills/_code-reviewer

Rename it back to re-enable.

Which skills to install first

If you're just getting started, here are a few skills that most developers find useful right away:

git-commit-writer — writes conventional commit messages by analyzing your staged changes
code-reviewer — reviews your code for bugs, security issues, and best practices
pr-description-writer — generates clear pull request descriptions from your branch diff
env-doctor — diagnoses why your project won't start

Browse more on the Agensi marketplace or check out the complete guide to SKILL.md if you want to understand how skills work under the hood.