Complete List of Supported Skill Discovery Paths in the Skills CLI

The skills CLI discovers skills by scanning 30+ predefined directories across conventional folders, hidden vendor namespaces, and plugin-declared paths.

The skills CLI from vercel-labs/skills implements a hierarchical discovery system that searches for skill definitions in a carefully ordered list of repository paths. This article documents every supported skill discovery path, explains their purposes, and shows how to leverage this system in your own projects.

Core Discovery Logic in src/skills.ts

The discovery mechanism centers on the discoverSkills() function in src/skills.ts, which constructs a priority search list (prioritySearchDirs) at lines 154–186. This array defines the exact order in which directories are examined for SKILL.md files.

The CLI evaluates paths in priority order, stopping early when matches are found—unless the --full-depth flag triggers a comprehensive recursive search.

Complete List of Supported Skill Discovery Paths

The prioritySearchDirs array contains the following 31 base paths, listed in evaluation order:

Order	Path	Purpose
1	. (repository root)	Skills placed directly in project root
2	skills/	Conventional top-level skills folder
3	skills/.curated/	Curated, production-ready skills
4	skills/.experimental/	Experimental or beta skills
5	skills/.system/	System-level or framework skills
6	.agents/skills/	Generic AI agent skills
7	.claude/skills/	Anthropic Claude-specific skills
8	.cline/skills/	Cline IDE skills
9	.codebuddy/skills/	Code::Buddy skills
10	.codex/skills/	OpenAI Codex skills
11	.commandcode/skills/	Command Code skills
12	.continue/skills/	Continue.dev skills
13	.github/skills/	GitHub Copilot or GitHub-native skills
14	.goose/skills/	Goose AI skills
15	.iflow/skills/	iFlow skills
16	.junie/skills/	JetBrains Junie skills
17	.kilocode/skills/	Kilo Code skills
18	.kiro/skills/	Kiro skills
19	.mux/skills/	Mux skills
20	.neovate/skills/	Neovate skills
21	.opencode/skills/	OpenCode skills
22	.openhands/skills/	OpenHands skills
23	.pi/skills/	Pi skills
24	.qoder/skills/	Qoder skills
25	.roo/skills/	Roo Code skills
26	.trae/skills/	Trae skills
27	.windsurf/skills/	Windsurf skills
28	.zencoder/skills/	Zencoder skills

After these 28 fixed paths, the CLI appends dynamic plugin-declared paths via getPluginSkillPaths(searchPath) from src/plugin-manifest.ts (lines 186–188).

Plugin-Declared Skill Discovery Paths

Projects can extend discovery through the plugin manifest system. The function getPluginSkillPaths() in src/plugin-manifest.ts parses plugin metadata and returns additional directories to search.

// From src/skills.ts, lines 186-188
const pluginPaths = await getPluginSkillPaths(searchPath);
prioritySearchDirs.push(...pluginPaths);

Plugin paths are appended after all built-in paths, meaning they have lower priority than conventional and vendor-specific locations.

Fallback: Full-Depth Recursive Search

When standard discovery fails or when explicitly requested, the CLI falls back to exhaustive recursion. The findSkillDirs function (referenced at lines 110–112 in src/skills.ts) walks the entire repository while respecting exclusion patterns from src/constants.ts (SKIP_DIRS includes node_modules, .git, dist, build, .next, etc.).

Trigger full-depth mode with:

skills discover --full-depth

Or programmatically:

const skills = await discoverSkills(process.cwd(), undefined, { fullDepth: true });

Practical Code Examples

List All Discovered Skills

import { discoverSkills } from './src/skills.ts';

async function listAllSkills() {
  const skills = await discoverSkills(process.cwd());
  
  console.log('Discovered skills:');
  skills.forEach(skill => {
    console.log(`  - ${skill.name} (${skill.path})`);
  });
}

listAllSkills();

Search a Subdirectory with Internal Skills

import { discoverSkills } from './src/skills.ts';

async function searchPluginArea() {
  const skills = await discoverSkills(
    process.cwd(),
    'packages/my-plugin',
    { includeInternal: true }
  );
  
  console.log(`Found ${skills.length} skills in plugin area`);
  return skills;
}

searchPluginArea();

Force Full-Depth Discovery

import { discoverSkills } from './src/skills.ts';

(async () => {
  // Bypass priority list entirely, scan everything
  const allSkills = await discoverSkills(
    process.cwd(),
    undefined,
    { fullDepth: true }
  );
  
  console.log(`Full-depth scan found ${allSkills.length} skills`);
})();

Key Implementation Files

File	Responsibility
src/skills.ts	Core discovery logic, discoverSkills() function, prioritySearchDirs array
src/plugin-manifest.ts	getPluginSkillPaths() for dynamic plugin-declared paths
src/constants.ts	SKIP_DIRS and other exclusion patterns for recursive search
src/sync.ts	Indirect usage of discoverSkills() for node_modules synchronization

Summary

• The skills CLI evaluates 31 built-in paths in strict priority order, from repository root through conventional folders to vendor-specific hidden directories
• Plugin-declared paths append dynamically via getPluginSkillPaths() in src/plugin-manifest.ts
• Discovery prioritizes standard locations; use --full-depth or findSkillDirs for exhaustive repository scans
• The system supports cross-vendor skill compatibility through its extensive hidden-folder convention (.claude/, .copilot/, .continue/, etc.)

Frequently Asked Questions

What is the first directory the skills CLI checks for skills?

The CLI first checks the repository root (.) itself, followed immediately by the skills/ subdirectory. This ordering ensures that skills placed at the top level get highest priority.

Can I add custom skill discovery paths to my project?

Yes, through the plugin manifest system. The getPluginSkillPaths() function in src/plugin-manifest.ts reads plugin metadata and returns additional directories to search. These paths are appended after all built-in locations.

Why does the CLI search so many hidden vendor folders?

The extensive list of vendor-specific paths (.claude/, .github/, .continue/, etc.) enables cross-compatibility with skills written for other AI assistants. This design allows teams to migrate or share skills across different tools without restructuring their repositories.

What happens if no skills are found in the priority directories?

If standard discovery yields no results, or when the --full-depth flag is used, the CLI triggers findSkillDirs for a recursive search of the entire repository. This fallback respects exclusion patterns from SKIP_DIRS in src/constants.ts to avoid scanning build artifacts and dependencies.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}