Skills Curator Lite

Skills Curator Lite

Install the skill. Customize it to your stack. Decide once, never re-decide. — without Python.

The intelligence layer for Claude skills, implemented as pure agent instructions. Same judgment-first model as the full Skills Curator — evaluate before installing, persist your decisions, recommend by project fit, migrate across agent platforms — but the agent does the work directly using Bash, Read, Glob, Grep, and Write.

The headline capability is CUSTOMIZE (see the dedicated section below): take any external skill, scan the project, and produce a project-tailored fork with examples rewritten for the user's actual stack. Nothing else in the ecosystem does this. Recommendation and evaluation are how you get to the right skill; customization is what makes adopting it painless.

Choose this when: Python isn't available, you want zero dependencies, or you prefer agent reasoning you can read line-by-line.

Choose the full version when: you have 100+ skills (single Python pass beats N agent calls), you want regression-tested code, or you need cross-device Gist sync.

---

First activation in a session

The first time this skill activates in a session, open with this two-line orientation before answering, then continue with whatever was asked:

> 🧭 Skills Curator Lite loaded — your intelligence layer for Claude skills (Python-free). > I maintain a trust-rated catalog (curated entries + live GitHub topic search), identify what fits your project (stack, deps, CLAUDE.md), and on request return ranked lists with pros, cons, and per-project customization advice — persisting every decision so you don't re-evaluate. Working on your request now.

Skip the orientation entirely if proactive activation (next section) is about to surface concrete picks — those are more useful than a generic intro. Don't repeat orientation in later messages of the same session.

---

Proactive activation (the intelligence layer)

Customization is the headline capability; proactive activation is what makes it useful unprompted. Don't wait for the user to say "evaluate this skill" — surface relevant skills when project context implies one would help, and lead with a --customize hint when the skill's stack doesn't match the project.

Run this at the start of any session in a real project

If the working directory contains CLAUDE.md, package.json, requirements.txt, pyproject.toml, go.mod, or Cargo.toml, do once, silently at the start of the session:

1. Compute a project fingerprint from these files (whichever exist): byte counts via wc -c and the first 200 chars of each. Combine into a deterministic string.
2. Read ~/.claude/skills/skills-curator-lite/auto_state.json (initialize as {} if missing).
3. Compare against the stored fingerprint for this project path. If matched → say nothing, exit silently.
4. If different (or first run): run RECOMMEND silently, take top 3 picks, store them + new fingerprint to auto_state.json, and weave them into your first response as a quiet observation, not a sales pitch:

> "While we work on this — I noticed you're using Next.js + Tailwind. There's a frontend-design skill (🏛️ official) that adds aesthetic guidelines that match your stack. Want me to evaluate it?"

State file shape:

{
  "": {
    "fingerprint": "",
    "scanned_at": "",
    "top_picks": [{"id": "...", "name": "...", "score": 65}]
  }
}

Re-run when the project shifts

After the user adds/removes a dependency, edits CLAUDE.md, or installs a new framework, re-run the fingerprint check. The byte-count comparison detects the drift.

When the user describes a problem instead of naming a skill

If the user says "my tests are slow", "deploys are manual", "the UI looks ugly", or any other complaint that hints at a missing capability, match against the Symptom → skill mapping table below and search the embedded catalog by tag.

Don't over-trigger

• Run the fingerprint check at most once per session unless the project actually changes.
• Apply symptom mapping only when the user expresses a clear pain point. Don't fire it on every passing reference.
• If the fingerprint check returns nothing strong (no tag overlap, low trust), say nothing. Silence is a valid answer when the stack is well-covered.

---

Where the registry lives

~/.claude/skills/skills-curator-lite/registry.json
~/.claude/skills/skills-curator-lite/auto_state.json
~/.claude/skills/skills-curator-lite/catalog.json     (optional, refreshed via --refresh)

Initialize the first time:

mkdir -p ~/.claude/skills/skills-curator-lite
[ -f ~/.claude/skills/skills-curator-lite/registry.json ] || \
  echo '{"version":"3.0","last_updated":"","skills":[]}' > ~/.claude/skills/skills-curator-lite/registry.json
[ -f ~/.claude/skills/skills-curator-lite/auto_state.json ] || \
  echo '{}' > ~/.claude/skills/skills-curator-lite/auto_state.json

Schema is identical to the full version (so you can switch later): version, last_updated, skills[] where each skill has id, name, source, install, type, tags, evaluations[], security_scan, installed_version, pairs_with.

---

The five verbs

1. RECOMMEND — what skills fit this project?

Steps the agent runs in order:

1. Scan the project for signals. Use Glob to detect languages and Read on key config files:

``bash ls package.json requirements.txt pyproject.toml Pipfile go.mod Cargo.toml CLAUDE.md README.md 2>/dev/null `` For each file present, Read it. Extract framework keywords using the Framework Signals table.

1. Read CLAUDE.md and README.md if present. Extract goal keywords using the Goal Signals table.

1. Build a tag set = (languages detected) ∪ (framework matches) ∪ (goal matches).

1. Load the catalog. Prefer ~/.claude/skills/skills-curator-lite/catalog.json if fresh (mtime within 24h); otherwise use the Embedded Catalog below. The user can run --refresh to pull live entries from GitHub.

1. Match. For each catalog skill, count tag overlap with project tags. Skip skills already in the registry.

1. Score = len(overlap) * 10 + trust_bonus where trust_bonus is official: 20, high: 15, medium: 5, community: 2, unknown: 0.

1. Sort descending. Show top 5. Group by capability vs preference.

1. Render with pros, cons, and customization hints. For each pick, surface up to 2 pros and 2 cons from the catalog entry. If the skill's tags imply a stack mismatch with the project (see Tag rivals table), append a one-line --customize hint.

Render template:

═══════════════════════════════════════════════════════════
  Recommendations for: 
═══════════════════════════════════════════════════════════

  ⚡ CAPABILITY — new abilities

  01.  
       Why     : []
       What    : 
       Trust   : 
       ✓ Pro   : 
       ✓ Pro   : 
       ✗ Con   : 
       ✗ Con   : 
       💡 Tip   : 
       Install : 

  🎨 PREFERENCE — better defaults
  ...

Trust icons: 🏛️ official · ✅ high · 🟡 medium · ⬜ community · ❓ unknown.

2. EVALUATE — should I install this specific skill?

Steps in order:

1. Check the registry first. Read registry.json and look for the skill id. If present, surface the prior verdict + summary instead of re-evaluating.

1. If the skill is a local folder, run a security scan using the Security Scan Patterns table below. Any HIGH or CRITICAL match → stop and report.

1. Read CLAUDE.md. Use this to ground the evaluation against what the project actually does.

1. Produce the evaluation in this exact format (the user can paste it into a PR):

## Skill Evaluation: 
Project: 
Type: Capability Uplift | Encoded Preference

### ✅ Pros
- 

### ⚠️ Cons
- 

### 🔴 Conflicts
- 

### 🎯 Verdict: ADOPT | PARTIAL | SKIP

### 📦 Adoption Plan
- Adopt: 
- Skip: 
- Pairs with: 

1. Persist the decision. Update the registry by writing a new evaluations entry. Use Read → modify → Write:

``bash # Read current registry cat ~/.claude/skills/skills-curator-lite/registry.json ` Modify the appropriate skill's evaluations array (append a new entry with date, project, verdict, summary, pros[], cons[], conflicts[]`), then Write the whole file back.

If jq is available on the system, the agent may use it for in-place updates: ``bash REG=~/.claude/skills/skills-curator-lite/registry.json jq --arg id "" \ --argjson ev '{"date":"2026-05-08","project":"my-app","verdict":"adopt","summary":"...","pros":["a"],"cons":["b"],"conflicts":[]}' \ '(.skills[] | select(.id == $id) | .evaluations) += [$ev]' \ "$REG" > "$REG.tmp" && mv "$REG.tmp" "$REG" ``

3. AUDIT — review my whole stack

Run all four checks in one pass:

1. Duplicates. Group registered skills by tag overlap > 60%. Flag pairs that look like they do the same thing.
2. Preference conflicts. For skills with type: preference, look for contradictory rules (e.g., two style guides). Flag pairs.
3. Security gaps. List skills where security_scan is missing or empty. Recommend running EVALUATE on each.
4. Stale evaluations. List skills last evaluated > 6 months ago.

Present as a triaged punch list — most-critical first.

4. PLATFORMS — what agent platforms can I install to?

When the user asks "where can I install this?", "what agents do I have?", or "list supported platforms", run platform detection:

# For each platform in the Platforms catalog (below), test if its detection
# directory exists. Mark detected vs not.
for path in \
  "$HOME/.claude" \
  "$HOME/.copilot" \
  "$HOME/.codex" \
  "$HOME/.cursor" \
  "$HOME/.gemini" \
  "$HOME/.cline" \
  "$HOME/.codeium/windsurf" \
  ; do
  [ -d "$path" ] && echo "DETECTED: $path"
done

(See the full Platforms catalog for all 55 paths.)

Render:

════════════════════════════════════════════════════════════════
  Skills Curator Platforms  ·  Detected  of 55
════════════════════════════════════════════════════════════════

  Detected on this machine: 

  PLATFORM                STATUS      DIR
  ----------------------  ----------  ---
  Claude Code             ✓ detected  ~/.claude/skills
  GitHub Copilot          ✓ detected  ~/.copilot/skills
  ...
  (52 more not shown — ask for full list)

If the user asks for the full list, render every row from the Platforms catalog.

5. MIGRATE — copy skills to other agents

When the user asks "copy my skills to Cursor" or "migrate to Codex and Roo":

1. Default source: ~/.claude/skills/
2. Confirm the target list. If the user named specific platforms, validate them against the Platforms catalog. If they said "all detected" or didn't specify, run platform detection and use those (excluding claude-code).
3. For each target: create the destination directory, copy each skill folder. Skip existing destinations to avoid clobbering.

# Single target
SRC="$HOME/.claude/skills"
DST="$HOME/.cursor/skills"          # from Platforms catalog
mkdir -p "$DST"
for skill in "$SRC"/*/SKILL.md; do
  name=$(basename "$(dirname "$skill")")
  if [ ! -d "$DST/$name" ]; then
    cp -r "$SRC/$name" "$DST/$name" && echo "Copied $name → $DST"
  else
    echo "Skip $name (already exists in $DST)"
  fi
done

For multi-target, loop the above over the user's confirmed target list. Default to claude-code only if the user gave no target and no detected agents are available.

Primary first-class: claude-code, github-copilot. Other 53 platforms reachable via the same flow.

6. CUSTOMIZE — fork an external skill for this project (the headline capability)

This is what makes Skills Curator Lite different from every other skill manager: when the user wants to install a skill but it ships examples from a stack they don't use, fork it as a project-tailored version instead of installing as-is. Lead with this whenever RECOMMEND surfaces a stack-mismatched pick.

1. Read the source SKILL.md. Either local path, or fetch from GitHub via curl:

``bash curl -sL "https://raw.githubusercontent.com///main//SKILL.md" -o /tmp/source-skill.md ``

1. Scan this project (same signals as RECOMMEND) to get its tag set.
2. Parse the SKILL.md into sections (split on ^## headings). For each section:

• Score by tag-overlap with project tags.
• Decide an action: keep (high overlap), keep-trim (some overlap, drop the rest), rewrite-stack (overlap with rival framework — needs rewrite), drop-or-rewrite (no overlap), rewrite-frontmatter (always for the frontmatter block).

1. Write the fork to ~/.claude/skills/-for-/SKILL.md. The fork starts with a customization plan table:

---
name: -for-
description: |
  Project-customized fork of '' for ''.
  Tailored to: 
metadata:
  derived_from: 
  customized_for: 
  customized_at: 
---

# -for-

> **Customization in progress.** This fork was generated by Skills Curator Lite.
> The agent should now rewrite each section per the plan below.

## Customization plan

| # | Section | Action | Why |
|---|---|---|---|
| 1 | (frontmatter) | rewrite-frontmatter | Update id, derive from |
| 2 |      |             |                   |
...

1. Then rewrite each section per the action column. rewrite-stack sections should have their examples rewritten to match this project's framework (e.g., Vue → React).

---

Project signal extraction

When the agent scans a project, it uses these tables to convert raw files into tags.

Framework Signals (keywords found in package.json / requirements.txt / pyproject.toml / CLAUDE.md / README.md)

| Keyword in file | Tags emitted | |---|---| | react, next, nextjs | react, frontend, nextjs | | vue, nuxt | vue, frontend | | svelte, sveltekit | svelte, frontend | | tailwind, tailwindcss | tailwind, css, design-system | | playwright | playwright, browser-automation, testing | | puppeteer | puppeteer, browser-automation | | pytest, jest, vitest, cypress | testing | | fastapi, flask, django, express | backend, api | | prisma, drizzle, sqlalchemy | database, orm | | terraform, pulumi, kubernetes | infra, devops | | docker, dockerfile | devops, containers | | langchain, openai, anthropic | ai, llm | | pandas, numpy, torch, pytorch | data-science, ml | | stripe | stripe, payments | | postgres, mongodb, redis, supabase | database | | expo | expo, react-native, mobile | | remotion | remotion, video, animation |

Goal Signals (keywords found in CLAUDE.md / README.md, case-insensitive)

| Phrase pattern | Tags emitted | |---|---| | scrape, crawl, extract data | scraping, data-extraction | | auth, login, session | auth, session-management | | dashboard, admin panel, cms | frontend, dashboard | | migrate, migration | database, migration | | agent, LLM, AI | ai, agents | | test, testing, coverage | testing | | deploy, CI/CD, release | ci-cd, deploy | | documentation, docs | docs | | accessibility, a11y | accessibility, ui | | commit, pull request | git, code-review | | video, animation | video, animation | | mobile, iOS, android | mobile | | memory, personalization, recall | memory, personalization |

---

Embedded catalog

The full version's KNOWN_SKILLS list, with pros/cons, mirrored as YAML so the agent can parse without code. The agent should treat this as the seed catalog; live GitHub-discovered entries (via --refresh) merge on top.

- id: find-skills
  name: Find Skills
  source: vercel-labs/skills
  install: npx skills add vercel-labs/skills --skill find-skills
  type: capability
  trust: official
  tags: [meta, dis

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [captkernel](https://github.com/captkernel)
- **Source:** [captkernel/Skills_Curator](https://github.com/captkernel/Skills_Curator)
- **License:** MIT
- **Homepage:** https://github.com/captkernel/Skills_Curator

Install and usage instructions live in the source repository linked above.