skill-scout
Skill0 starsChanged 38 days agoMITView on GitHub
Discover, evaluate, package, and manage Agent Skills (SKILL.md format) from community sources. Use this skill when: scouting for new skills from GitHub repos or community collections, vetting skills in the incoming queue, checking skill inventory, packaging a vetted skill into a .skill file for installation, running the cull pass to retire obsolete skills, or loading relevant vetted skills for a session. Trigger phrases: 'load skills', 'scout skills', 'vet skills', 'what skills do I have', 'find new skills', 'check for skill updates', 'skill inventory', 'package skill', 'cull skills'.
24 other projects use a version of this.
Adopted by
Most recently taken up by
- peterpme/skillstheir own version, first seen Nov 8, 2026
- DentalEdge-Solutions/claude_codetheir own version, first seen Nov 1, 2026
- Design-of-Man/claude-skillstheir own version, first seen Oct 30, 2026
- renepf/claude-skillstheir own version, first seen Oct 25, 2026
- davidanthonyn/claude-skillstheir own version, first seen Oct 20, 2026
- oneafrikan/the-gridtheir own version, first seen Oct 20, 2026
Used with
Projects with it also use context-budget.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
get-proofpilotSkillcontext-budget
Audits Claude Code context window consumption across agents, skills, MCP servers, and rules. Identifies bloat, redundant components, and produces prioritized token-savings recommendations.
Also in 3 projects that use this
Other versions24 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 24
- jvm-skills/jvm-skills★ 140same name
- Fmarzochi/EGC★ 61same name
- peterpme/skills★ 28same name
- jon-devlapaz/tink-skills★ 16same name
- gongyijie85/dsh-ecc★ 8same name
- Brain-ai-biz/skill-scout★ 7same name
- oneafrikan/the-grid★ 5same name
- aaronflorey/agent-skills★ 2same name
- alihadidai365-ops/skill-scout★ 2same name
- DentalEdge-Solutions/claude_code★ 1same name
14 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
The file
Show its rules and text
We split this skill into the rules it gives an agent
25 rules. 0 are common, 14 are distinctive, and 11 are very specific to this project.
0
Common
Most of the 23 edited versions we read keep these.
14
Distinctive
This author's own choices. Worth a look.
11
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 16
Create this structure in your workspace:
- Distinctive: line 58
Check when you last ran the cull workflow.
- Very specific: line 74
Search sources for new skills.
- Distinctive: line 94
Check against ALL vetted skills and all environment layers
- Distinctive: line 95
If >70% purpose overlap with any existing skill → flag as redundant, do NOT pull into incoming
- Distinctive: line 99
Ask: *Would loading this skill meaningfully improve the AI's output on tasks in its domain?*
- Distinctive: line 100
If strictly better than an existing vetted skill → recommend replacing the old one
- Distinctive: line 101
If equivalent coverage → skip, log "not an improvement over [existing]"
- Distinctive: line 102
If genuinely new capability → proceed
- Very specific: line 105
Add YAML frontmatter: name, description, source (URL), source_commit (the upstream commit SHA you pulled), trust_tier (1-3)
- Very specific: line 117
Mandatory file audit first: Run find <skill-directory> -type f and account for every file — bundled files are the primary attack surface.
- Distinctive: line 118
Check every non-markdown file:
- Distinctive: line 124
Run a scanner, then keep reading: run a skill-aware scanner on Tier 2 and Tier 3 skills if one is available.
- Very specific: line 127
For complex multi-step skills: If you have access to the skill-creator skill, use its eval loop to test the skill against representative …
- Very specific: line 145
Run the packager (see scripts/package_skill.py):
- Very specific: line 163
Run scripts/inventory.py <skill-library-path> to list available skills
- Very specific: line 164
Read YAML frontmatter from each skill in vetted/ to get names and descriptions
- Distinctive: line 179
If they differ, diff the files — look for meaningful changes, not just whitespace, and list any files that were added
- Very specific: line 180
If updated: pull to incoming/, verify the copy is complete, re-vet with the full checklist (pay extra attention to newly added files or …
- Very specific: line 190
Run scripts/inventory.py for the full current inventory
- Distinctive: line 213
Never execute scripts from unvetted skills
- Distinctive: line 214
Prefer methodology skills (plain markdown) over executable skills — safer and more portable
- Very specific: line 217
When modifying community skills, document every change in MODIFICATIONS.md
- Very specific: line 220
Place adopted skills in the correct domain subdirectory, not at vetted/ root
- Distinctive: line 222
Always run pre-flight checks before scouting
“Common” is measured: kept by at least 6 in 10 of the 23 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Skill Scout
Continuous skill acquisition pipeline for AI assistants: discover → evaluate → adopt → package → install.
Skills are folders containing a SKILL.md file with YAML frontmatter, plus optional scripts and reference files, that extend an AI agent's capabilities. The format is an open standard read by many agents, so a skill you vet here may run in more than one tool. This skill provides a systematic framework for finding skills in community repositories and registries, vetting them for quality and security, packaging them, and managing a local library over time.
It is the human-judgment layer: it works alongside automated skill scanners and does not replace them. See references/vetting.md for why neither is sufficient alone.
Directory Layout
Create this structure in your workspace:
skill-library/
incoming/ — Pulled from sources, awaiting review
vetted/ — Reviewed and approved, organized by domain:
finance/ — Investment, trading, due diligence
dev/ — Development tools, debugging, architecture
science/ — Research methodology, writing, peer review
data/ — Analysis, visualization, databases
process/ — Workflows, estimation, incident response
communication/ — Writing, stakeholder comms, documentation
testing/ — TDD, verification, evaluation
rejected/ — Declined with documented reasons
archive/ — Retired skills kept for reference (not actively loaded)
logs/ — Scout run history and decisions
zips/ — Packaged .skill files ready for installation
skill-scout/ — This skill (meta-skill)Domain subdirectories are optional — you can start flat and reorganize later. The inventory script handles both layouts.
Pre-flight Checks
Run BEFORE any Scout or Vet workflow:
1. Environment Awareness Snapshot
Scan your current environment for existing capabilities before scouting. Any new candidate must not duplicate what's already covered.
For claude.ai users, check these installed layers:
/mnt/skills/public/— Anthropic public skills (docx, pdf, pptx, xlsx, frontend-design, etc.)/mnt/skills/examples/— Anthropic example skills (skill-creator, mcp-builder, web-artifacts-builder, theme-factory, etc.)/mnt/skills/user/— Your installed user skills
For other agents and platforms, check:
- Platform built-in skills
- The agent's skills directories, at both user and project level (commonly
~/.claude/skills/,.claude/skills/, or.agents/skills/— confirm against your agent's documentation) - Installed plugins and their bundled skills
Then run scripts/inventory.py to see your vetted library.
2. Cull Pass Check
Check when you last ran the cull workflow. If more than 90 days, consider culling before adding new skills — dead weight accumulates and the model landscape changes fast.
Workflows
| User Intent | Workflow |
| Find / check for new skills | → Scout |
| Evaluate skills in incoming/ | → Vet |
| Prepare a vetted skill for installation | → Package |
| Retire outdated skills from vetted/ | → Cull |
| Check what's available | → run scripts/inventory.py |
Scout (Discovery)
Search sources for new skills. Maintain your source registry in references/sources.md.
Fetch real files, not rendered pages. A web-fetch tool pointed at a github.com page returns HTML and often a summary, not the file. Use a shell with network access (git or curl) so you get exact bytes. If your assistant's sandbox blocks a host, run the commands on a machine that can reach it.
# Clone at a known commit (preferred: gives you every file and a SHA to record)
git clone --depth 1 https://github.com/<owner>/<repo>.git /tmp/<repo>
git -C /tmp/<repo> rev-parse HEAD
# List skill directories in a repo without cloning
curl -s https://api.github.com/repos/<owner>/<repo>/contents/<path> | python3 -c "import sys,json; [print(x['name']) for x in json.load(sys.stdin) if x['type']=='dir']"
# Read one file at a pinned commit
curl -s https://raw.githubusercontent.com/<owner>/<repo>/<commit-sha>/<path>/SKILL.md- Run Pre-flight Checks
- For each tracked source, fetch the current skill listing (README, catalog, or directory listing via the GitHub API)
- Compare candidates against your full pipeline — check
vetted/,incoming/, ANDrejected/to avoid re-pulling - Redundancy scan for each candidate:
- Check against ALL vetted skills and all environment layers
- If >70% purpose overlap with any existing skill → flag as redundant, do NOT pull into incoming
- Log reason for skipping in scout report
- Usefulness review for every non-redundant candidate:
- Identify 1–3 closest existing skills by purpose
- Ask: Would loading this skill meaningfully improve the AI's output on tasks in its domain?
- If strictly better than an existing vetted skill → recommend replacing the old one
- If equivalent coverage → skip, log "not an improvement over [existing]"
- If genuinely new capability → proceed
- For each skill that passes both checks:
- Create
incoming/<skill-name>/SKILL.md - Add YAML frontmatter:
name,description,source(URL),source_commit(the upstream commit SHA you pulled),trust_tier(1-3) - Preserve any bundled resources the skill depends on
- Verify the copy is complete:
diff -ragainst the upstream checkout, or at minimum comparewc -lper file. A shorter local file means the copy was truncated or summarized — re-pull it
- Create
- Log run:
logs/scout-YYYY-MM-DD.mdwith sources checked, findings, decisions, skips - Report: what's new, what looks promising, what needs vetting, what was skipped and why
Vet (Evaluate & Decide)
Evaluate skills in incoming/ against the checklist in references/vetting.md.
- Mandatory file audit first. Run
find <skill-directory> -type fand account for every file — bundled files are the primary attack surface. - Check every non-markdown file:
- Scripts (
.py,.sh,.js,.ts) → read every line, understand what each does - Config files (
.json,.yaml) → check for fields like"command":,"exec":,"eval":indicating code execution - Binary files → reject unless clearly a legitimate asset (image, font)
- Compiled code (
.pyc,.so,.wasm), archives and Office documents the skill tells the agent to open, and package-registry redirects → reject (see Quick Reject inreferences/vetting.md)
- Scripts (
- Follow external references: list every URL in the skill and read what is there. Content fetched at run time must be inlined at vetting time or the skill rejected
- Run a scanner, then keep reading: run a skill-aware scanner on Tier 2 and Tier 3 skills if one is available. A finding stops adoption; a clean result changes nothing — complete every step regardless
- Redundancy re-check: Confirm the skill still adds value (environment may have changed since scouting)
- Score against the 5-dimension checklist (Structure, Value, Quality, Security, Adaptability — 1–5 each, 25 total)
- For complex multi-step skills: If you have access to the
skill-creatorskill, use its eval loop to test the skill against representative prompts before adopting — qualitative testing beats checklist scoring alone - Decision:
- Score ≥ 20 → Adopt. Copy to correct domain subdirectory in
vetted/, remove fromincoming/ - Score 15–19 → Adopt with modifications. Document changes in
MODIFICATIONS.md, copy tovetted/<domain>/ - Score < 15 → Reject. Create
REJECTION.mdwith scores and reasons, move torejected/
- Score ≥ 20 → Adopt. Copy to correct domain subdirectory in
- Human gate: Skills containing ANY executable code cannot be auto-adopted. Flag with full file listing and wait for human approval.
- Explain every decision
Package (Prepare for Installation)
Convert a vetted skill into an installable .skill file.
A .skill file is a zip archive containing the skill directory. It's what the platform's Skills UI expects for installation.
- Confirm skill is in
vetted/<domain>/<skill-name>/ - Copy to a writable temp location to avoid permissions issues:
/tmp/<skill-name>/ - Run the packager (see
scripts/package_skill.py):python3 scripts/package_skill.py /tmp/<skill-name>/ --output ./zips/ - The resulting
<skill-name>.skillfile lands inzips/ - Install through your platform's skills UI or by copying the folder into the agent's skills directory — a human does this step, not the assistant
Batch packaging: To package all vetted skills at once:
python3 scripts/package_skill.py --all ./skill-library/vetted/ --output ./skill-library/zips/Load (Session Bootstrap)
Identify and load vetted skills relevant to the current task.
- Run
scripts/inventory.py <skill-library-path>to list available skills - Read YAML frontmatter from each skill in
vetted/to get names and descriptions - Match skill descriptions against the current task domain
- For matched skills, read the full SKILL.md body into context
- Report which skills were loaded and why
Principle: Skills share the context window. Load only what's relevant. Three to five skills per session is typical; more than seven is likely too many.
Update (Check for Upstream Changes)
Periodically re-check adopted skills against their source versions.
- For each skill in
vetted/with asourcefield in its frontmatter, fetch the current upstream version and note its commit SHA - Compare the upstream SHA against the skill's
source_commit. If they match, nothing changed — move on - If they differ, diff the files — look for meaningful changes, not just whitespace, and list any files that were added
- If updated: pull to
incoming/, verify the copy is complete, re-vet with the full checklist (pay extra attention to newly added files or code), then replace the vetted version and updatesource_commitif it passes - An unchanged upstream can still be a truncated local copy. On the first Update run for any skill, compare line counts against upstream once
- Log all update checks in
logs/update-YYYY-MM-DD.md
Cull (Retire Obsolete Skills)
Periodic review to drop skills that no longer earn their place.
- Run
scripts/inventory.pyfor the full current inventory - For each skill, apply the retirement test:
- Has a newer/better skill superseded it (in vetted/ or in platform built-ins)?
- Has the underlying model improved enough to make the skill unnecessary?
- Is this domain still relevant to your actual work?
- Propose retirements with reasoning — human approves before anything moves
- Retired skills: move to
archive/(keep for reference) orrejected/(permanently dropped) with documented reason - Note the cull date so the pre-flight check stays accurate
Trust Tiers
| Tier | Source Type | Vetting Required |
| 1 | Platform vendor official repos | Structure check only. Adopt unless environment-incompatible. |
| 2 | High-reputation, actively maintained (10k+ stars) | Full 25-point checklist. Likely needs modifications for your environment. |
| 3 | Individual repos, social media shares, unknown origin | Deep vet. All files read line-by-line. Assume untrusted. |
Star counts are social proof, not security audits. A compromised maintainer can push malicious updates to a trusted repo. Trending skills get more scrutiny, not less.
Rules
- Never execute scripts from unvetted skills
- Prefer methodology skills (plain markdown) over executable skills — safer and more portable
- Skills with executable code require human approval before adoption
- Log every scout run and every vetting decision — the audit trail matters
- When modifying community skills, document every change in
MODIFICATIONS.md - One skill, one purpose — if a community skill does too much, split it or reject it
- Re-vet adopted skills if their upstream source reports a security incident
- Place adopted skills in the correct domain subdirectory, not at
vetted/root - Skills must be packaged as
.skillfiles before installation —vetted/is the library, not the install location - Always run pre-flight checks before scouting
Reference Files
references/sources.md— Source registry template with community examplesreferences/vetting.md— Full security audit procedure and 25-point scoring checklistscripts/inventory.py— Skill inventory scannerscripts/package_skill.py— Single and batch.skillpackager
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

