agentleFS
goejgogoejgo/AI-Skill-Scout/SKILL.md

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

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-proofpilotSkill

    context-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

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
  1. Distinctive:

    Create this structure in your workspace:

    line 16
  2. Distinctive:

    Check when you last ran the cull workflow.

    line 58
  3. Very specific:

    Search sources for new skills.

    line 74
  4. Distinctive:

    Check against ALL vetted skills and all environment layers

    line 94
  5. Distinctive:

    If >70% purpose overlap with any existing skill → flag as redundant, do NOT pull into incoming

    line 95
  6. Distinctive:

    Ask: *Would loading this skill meaningfully improve the AI's output on tasks in its domain?*

    line 99
  7. Distinctive:

    If strictly better than an existing vetted skill → recommend replacing the old one

    line 100
  8. Distinctive:

    If equivalent coverage → skip, log "not an improvement over [existing]"

    line 101
  9. Distinctive:

    If genuinely new capability → proceed

    line 102
  10. Very specific:

    Add YAML frontmatter: name, description, source (URL), source_commit (the upstream commit SHA you pulled), trust_tier (1-3)

    line 105
  11. Very specific:

    Mandatory file audit first: Run find <skill-directory> -type f and account for every file — bundled files are the primary attack surface.

    line 117
  12. Distinctive:

    Check every non-markdown file:

    line 118
  13. Distinctive:

    Run a scanner, then keep reading: run a skill-aware scanner on Tier 2 and Tier 3 skills if one is available.

    line 124
  14. Very specific:

    For complex multi-step skills: If you have access to the skill-creator skill, use its eval loop to test the skill against representative …

    line 127
  15. Very specific:

    Run the packager (see scripts/package_skill.py):

    line 145
  16. Very specific:

    Run scripts/inventory.py <skill-library-path> to list available skills

    line 163
  17. Very specific:

    Read YAML frontmatter from each skill in vetted/ to get names and descriptions

    line 164
  18. Distinctive:

    If they differ, diff the files — look for meaningful changes, not just whitespace, and list any files that were added

    line 179
  19. Very specific:

    If updated: pull to incoming/, verify the copy is complete, re-vet with the full checklist (pay extra attention to newly added files or …

    line 180
  20. Very specific:

    Run scripts/inventory.py for the full current inventory

    line 190
  21. Distinctive:

    Never execute scripts from unvetted skills

    line 213
  22. Distinctive:

    Prefer methodology skills (plain markdown) over executable skills — safer and more portable

    line 214
  23. Very specific:

    When modifying community skills, document every change in MODIFICATIONS.md

    line 217
  24. Very specific:

    Place adopted skills in the correct domain subdirectory, not at vetted/ root

    line 220
  25. Distinctive:

    Always run pre-flight checks before scouting

    line 222

“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.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

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 IntentWorkflow
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
  1. Run Pre-flight Checks
  2. For each tracked source, fetch the current skill listing (README, catalog, or directory listing via the GitHub API)
  3. Compare candidates against your full pipeline — check vetted/, incoming/, AND rejected/ to avoid re-pulling
  4. 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
  5. 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
  6. 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 -r against the upstream checkout, or at minimum compare wc -l per file. A shorter local file means the copy was truncated or summarized — re-pull it
  7. Log run: logs/scout-YYYY-MM-DD.md with sources checked, findings, decisions, skips
  8. 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.

  1. Mandatory file audit first. Run find <skill-directory> -type f and account for every file — bundled files are the primary attack surface.
  2. 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 in references/vetting.md)
  3. 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
  4. 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
  5. Redundancy re-check: Confirm the skill still adds value (environment may have changed since scouting)
  6. Score against the 5-dimension checklist (Structure, Value, Quality, Security, Adaptability — 1–5 each, 25 total)
  7. For complex multi-step skills: If you have access to the skill-creator skill, use its eval loop to test the skill against representative prompts before adopting — qualitative testing beats checklist scoring alone
  8. Decision:
    • Score ≥ 20 → Adopt. Copy to correct domain subdirectory in vetted/, remove from incoming/
    • Score 15–19 → Adopt with modifications. Document changes in MODIFICATIONS.md, copy to vetted/<domain>/
    • Score < 15 → Reject. Create REJECTION.md with scores and reasons, move to rejected/
  9. Human gate: Skills containing ANY executable code cannot be auto-adopted. Flag with full file listing and wait for human approval.
  10. 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.

  1. Confirm skill is in vetted/<domain>/<skill-name>/
  2. Copy to a writable temp location to avoid permissions issues: /tmp/<skill-name>/
  3. Run the packager (see scripts/package_skill.py):
    python3 scripts/package_skill.py /tmp/<skill-name>/ --output ./zips/
  4. The resulting <skill-name>.skill file lands in zips/
  5. 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.

  1. Run scripts/inventory.py <skill-library-path> to list available skills
  2. Read YAML frontmatter from each skill in vetted/ to get names and descriptions
  3. Match skill descriptions against the current task domain
  4. For matched skills, read the full SKILL.md body into context
  5. 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.

  1. For each skill in vetted/ with a source field in its frontmatter, fetch the current upstream version and note its commit SHA
  2. Compare the upstream SHA against the skill's source_commit. If they match, nothing changed — move on
  3. If they differ, diff the files — look for meaningful changes, not just whitespace, and list any files that were added
  4. 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 update source_commit if it passes
  5. An unchanged upstream can still be a truncated local copy. On the first Update run for any skill, compare line counts against upstream once
  6. 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.

  1. Run scripts/inventory.py for the full current inventory
  2. 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?
  3. Propose retirements with reasoning — human approves before anything moves
  4. Retired skills: move to archive/ (keep for reference) or rejected/ (permanently dropped) with documented reason
  5. Note the cull date so the pre-flight check stays accurate

Trust Tiers

TierSource TypeVetting Required
1Platform vendor official reposStructure check only. Adopt unless environment-incompatible.
2High-reputation, actively maintained (10k+ stars)Full 25-point checklist. Likely needs modifications for your environment.
3Individual repos, social media shares, unknown originDeep 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

  1. Never execute scripts from unvetted skills
  2. Prefer methodology skills (plain markdown) over executable skills — safer and more portable
  3. Skills with executable code require human approval before adoption
  4. Log every scout run and every vetting decision — the audit trail matters
  5. When modifying community skills, document every change in MODIFICATIONS.md
  6. One skill, one purpose — if a community skill does too much, split it or reject it
  7. Re-vet adopted skills if their upstream source reports a security incident
  8. Place adopted skills in the correct domain subdirectory, not at vetted/ root
  9. Skills must be packaged as .skill files before installation — vetted/ is the library, not the install location
  10. Always run pre-flight checks before scouting

Reference Files

  • references/sources.md — Source registry template with community examples
  • references/vetting.md — Full security audit procedure and 25-point scoring checklist
  • scripts/inventory.py — Skill inventory scanner
  • scripts/package_skill.py — Single and batch .skill packager

Download now (ZIP)

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
What did you use it for? e.g. Reviewing pull requests in a Rails app

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.