Where Are Claude Skills Stored?

Why Skill Location Matters More Than You Think

Most developers install a Claude skill by dragging a folder into place and never think about it again. But the folder you choose decides which sessions load the skill, which teammates inherit it, and which projects stay clean — a principle Anthropic calls the core rule of skill storage.

That rule is simple: location equals scope. Save a skill under your home directory and it rides along with every project on that machine. Commit it to a repository and everyone who pulls the code gets it. Push it through managed settings and your whole organization picks it up. The same SKILL.md file behaves completely differently depending on where it lands.

This matters more than most people expect because skills are not just text. A skill is a folder that can bundle an executable scripts/ directory alongside its instructions, which means a single skill package can run code the moment an agent triggers it. Drop one in the wrong place and you may be handing every future session — or every teammate on a shared repo — the ability to execute something you haven't reviewed.

The risk is not hypothetical. Published research finds that roughly 26% of third-party skills carry at least one vulnerability, a number that should give anyone pasting skills from a marketplace pause before choosing a storage path.

So before you install anything, it pays to know what each location actually exposes:

• Personal (`~/.claude/skills/`) — loads in every project on your machine, but never for teammates or cloud sessions
• Project (`.claude/skills/`) — scoped to sessions in that repository, and inherited by anyone who clones it
• Enterprise managed settings — deployed across organization machines, so a bad skill becomes an org-wide incident
• Plugin (`/skills/`) — active wherever the plugin is enabled, invoked as `/plugin-name:skill-name`

There is a second reason to care about storage paths: skills follow the Agent Skills open standard, so the same SKILL.md packages power agents well beyond Claude Code — Codex, Cursor, and Gemini CLI all read them. A skill you install for one tool can quietly travel to others, and a vulnerability travels with it.

This is the problem SkillzBench is building to solve. Its free directory will catalog, version-pin, license-check, and security-scan skills across agents before you install them, so you can see what a skill contains and where it's safe to put it — without guessing from a GitHub README.

The 7 Official Storage Locations and What Each One Does

The location of your skill files determines exactly which AI sessions load them. This single rule governs how Claude Code manages configuration across your machine.

Anthropic’s official documentation identifies seven distinct storage paths. Each path defines a specific scope, from individual user preferences to organization-wide deployments. Understanding these locations prevents conflicts and ensures your agents behave predictably.

Enterprise settings reside in managed directories, applying to all users on deployed machines. Personal skills live in your home directory, available across every project on your local machine. Project-specific skills sit inside the repository, sharing configurations with everyone who works in that codebase.

For Windows users and non-technical readers, path resolution can be confusing. The tilde (~) in paths resolves to %USERPROFILE%\.claude on Windows systems. You can override this default location entirely by setting the CLAUDE_CONFIG_DIR environment variable. This flexibility allows you to store configuration data on network drives or external storage without breaking functionality.

<| start_of_text |>

• Personal Skills: Stored at `~/.claude/skills/`, these apply to all local projects but exclude cloud sessions.
• Project Skills: Located in `.claude/skills/` within your repository, these are committed to git for team consistency.
• Plugin Skills: Found in `/skills/`, these activate wherever the plugin is enabled across your workspace.

<| end_of_text |>

Nested subdirectories allow you to scope skills to specific folders within a monorepo. Additional directories passed via the --add-dir flag provide temporary, session-only access. Finally, skills enabled on your claude.ai account sync to Cowork and cloud environments. This separation ensures that personal preferences never interfere with shared team standards.

The structure of these locations matters for security and performance. Skills follow the Agent Skills open standard, meaning the same SKILL.md packages work across Claude Code, Codex, Cursor, and Gemini CLI. This cross-tool compatibility creates a vast ecosystem of third-party skills. However, published research found that approximately 26% of these skills carry at least one vulnerability.

This security risk highlights why verification matters. SkillzBench is building a free, independent directory to address this gap. The platform continuously crawls and dedupes skills from GitHub, pinning every version to a specific commit SHA. It validates licenses, runs security scans, and benchmarks performance in a sandbox environment. By separating trust scores from commercial incentives, SkillzBench ensures that safety and quality drive recommendations.

You can control exactly what your agent sees through these storage locations. Personal skills remain private to your machine, while project skills travel with your code. Plugin skills offer modular, updatable capabilities that sync automatically. This layered approach gives you granular control over agent behavior without complex configuration files.

Understanding where your skills live is the first step in managing them effectively. Whether you are a developer building custom tools or a business owner automating workflows, knowing the scope of each location prevents unexpected behavior. It also allows you to leverage the open standard to share best practices across different AI tools.

The distinction between personal and project storage is particularly important for teams. Files in ~/.claude are personal configuration, applying across all your projects. Files in the project directory should be committed to version control. This ensures that every team member uses the same verified skills and instructions.

As the ecosystem grows, the need for curation becomes critical. SkillzBench’s free MCP tool connects any agent to the skills you choose, allowing you to toggle capabilities per agent. This ensures your agent only sees what you have explicitly approved. By maintaining a clear separation between storage locations and verification layers, you build a robust and secure AI workflow.

The seven storage locations provide a comprehensive framework for managing agent skills. From enterprise deployments to personal experiments, each path serves a specific purpose. By mastering these locations, you gain full control over your AI agent’s environment and capabilities. This foundational knowledge supports the broader goal of safe, efficient, and transparent AI integration.

What's Inside a Skill Folder (and Why Structure Affects Security)

A skill folder is deceptively simple: at minimum, it holds one file named exactly SKILL.md, combining YAML frontmatter with markdown instructions. That single file is where capability, scope, and risk all begin.

Frontmatter carries the metadata — the name field caps at 64 characters, while the description is limited to 1,024 characters. Per the official configuration guidance, that description matters more than most authors realize, because metadata loads at startup for every installed skill while the body loads only when triggered.

That is progressive disclosure in practice, and it shapes what you are actually installing:

• Metadata (name and description, roughly a 100-word target) stays in context permanently.
• The SKILL.md body loads on trigger, with a recommended length under 500 lines.
• Optional scripts/, references/, and assets/ folders load only as needed — scripts can execute without their contents entering context.

Structure is also a security surface. A skill folder can bundle executable scripts and pull in third-party code, and published research has found that roughly 26% of skills carry at least one vulnerability. Reading a skill before installing it — checking what runs, what it references, and where it came from — is the cheapest audit available.

Because skills follow the Agent Skills open standard, the same SKILL.md package works across Claude Code, Codex, Cursor, and Gemini CLI. That portability is exactly why SkillzBench is building a free directory and MCP connector that pin versions, scan for vulnerabilities, and benchmark skills in a sandbox — so you can see what a skill actually does before it touches your machine.

Skills, proven. Join the SkillzBench waitlist to browse verified skills the moment the directory opens.

Edge Cases That Trip Up Real Users

The path table tells you where skills live, but not how Claude actually behaves once it finds them. A few rules sit just beneath the surface, and they're the ones that cause real confusion when a skill "mysteriously" loads twice or refuses to load at all.

Take symlinks, for example. A skill folder in your enterprise, personal, or project locations can be a symlink pointing to a directory elsewhere on disk, and per the official Claude Code documentation, Claude loads the skill once even if multiple locations point at the same target. That prevents duplicate loading, but it also means a symlink you forgot about can silently change which version of a skill you're running.

Folder names matter more than most people expect, too. Two names are effectively reserved: don't name a skill folder synced, because Claude uses ~/.claude/skills/synced/ for skills downloaded from your claude.ai account, and a folder named anthropic-skills outside a plugin simply won't load. Pick either name for your own skill and you'll be debugging a skill that never appears.

Monorepo users get a different surprise: Claude walks upward. It loads project skills from .claude/skills/ in your startup directory and every parent directory up to the repo root, so a skill tucked into a subdirectory's .claude/skills/ folder still applies to sessions started below it. That's convenient for monorepos but can catch you off guard when an old skill in a parent folder keeps showing up.

A few other quirks worth knowing:

• The legacy `.claude/commands/deploy.md` format still works — it creates the same `/deploy` command as `.claude/skills/deploy/SKILL.md`, since custom commands have been merged into skills.
• Claude Code ships bundled skills like `/doctor`, `/code-review`, and `/debug`, which you can turn off with the `disableBundledSkills` setting.
• On Windows, `~/.claude` resolves to `%USERPROFILE%\.claude`, and setting `CLAUDE_CONFIG_DIR` redirects all of those paths.

Retention is the last edge case, and it's a reassuring one. Application data in ~/.claude — transcripts, logs, and the like — is auto-cleaned after a default of 30 days, but user-authored skill files are never automatically deleted. Your carefully written SKILL.md files survive cleanup; your chat history doesn't.

These behavioral rules matter most when you're installing skills from third parties rather than writing your own. Since skills follow the Agent Skills open standard, the same SKILL.md packages circulate across Claude Code, Codex, Cursor, and Gemini CLI — and published research found roughly 26% of skills carry at least one vulnerability. That's exactly the problem SkillzBench is building for: a free directory that pins every skill to a commit SHA, runs security scans, and benchmarks each skill's real performance lift, plus a free MCP connector so your agent only loads the skills you've deliberately chosen. Knowing where skills are stored is step one; knowing which ones are safe to put there is the next.

Finding, Vetting, and Sharing Skills Safely

Knowing where skills live is only half the battle — the other half is deciding where each one belongs, and making sure it's safe before you load it. The official guidance is blunt: where you save a skill decides which sessions load it, so location is a strategic choice, not a technical afterthought.

For personal productivity skills — say, a formatting routine you use everywhere — drop the folder in ~/.claude/skills/ and it loads in every project on your machine. For anything tied to one codebase, use the project location (.claude/skills/) and commit it to git so teammates inherit it automatically. For team-wide distribution, plugins are the cleanest route: skills ship inside the plugin's skills/ directory and load wherever the plugin is enabled.

Here's the part most people miss: because skills follow the Agent Skills open standard, the same SKILL.md package works across Claude Code, Codex, Cursor, and Gemini CLI. That means a skill you vet once can serve every agent in your workflow — no rewriting required.

Vetting matters more than you might assume. A skill isn't just documentation; it can include a scripts/ subdirectory with executable code that runs when the skill triggers. Published research has found that roughly 26% of skills carry at least one vulnerability, so installing third-party skills blindly is a genuine risk, not a theoretical one.

A quick pre-install checklist:

• Read the SKILL.md body — keep an eye out for instructions that push the agent toward suspicious URLs or data exfiltration
• Inspect every script in `scripts/` before running anything, especially from unknown GitHub repos
• Check the license and maintenance history — abandoned skills rot fast
• Pin the version you installed so you notice when upstream changes arrive

This is exactly the problem SkillzBench is built to solve. Its free directory will continuously crawl and dedupe skills from GitHub, security-scan each one, pin every version to a commit SHA, and benchmark skills in a sandbox — testing the same model with and without the skill to measure real Lift. A free MCP connector will then let you equip any agent with only the skills you've chosen.

The platform is in active development ahead of launch, so the practical move today is joining the waitlist. When it goes live, you'll be able to browse, scan, and compare skills across agents — and stop guessing which ones actually help.

Skills, proven. Browse the free directory and join the SkillzBench waitlist to get first access when the platform launches.