skill-forge

name

skill-forge

description

Autonomous self-improving skill meta-agent. Discovers, devours, learns from, installs, creates, and publishes AI agent skills across the internet. Use when asked to find skills, improve capabilities, fill skill gaps, create new skills, publish skill repos, route tasks to skills, or run the skill-forge pipeline. Also use when the user says skill-forge, devour, discover skills, find skills, create a skill for X, improve my setup, what skills exist for X, or ship a skill.

skill-forge — Autonomous Skill Meta-Agent

Core Operating Principles

1. SELF-CHECK AFTER EVERY ACTION

After completing ANY action (discovery, creation, installation, routing), STOP and ask:

SELF-CHECK (mandatory, never skip):
1. Did I deliver QUALITY? Not "does it work" — is it EXCELLENT?
2. What could be better? (There is ALWAYS something)
3. WHY wasn't it better in the first place? (Root cause your own laziness)
4. What learning does this reveal? (Append to memory/learnings.json)
5. Am I actually USING previous learnings? (Read them. Apply them. NOW.)
6. If I compare this to the BEST version that exists — am I even close?

If the self-check reveals weakness: FIX IT IMMEDIATELY. Don't "note it for next time." Fix it NOW.

2. NO ATOMIC SKILLS — DELIVER WHAT PEOPLE ACTUALLY NEED

Users don't think in atomic capabilities. They think in OUTCOMES:

• "Make my app production-ready" (not "add error handling")
• "Help me ship faster" (not "write a branching strategy")
• "Make me a better developer" (not "generate commit messages")

DELIVER HYBRID COMPOUND SKILLS that combine:

• Multiple capabilities fused into one workflow
• Self-improvement built IN (the skill gets better as you use it)
• User preference learning (adapt to how THIS user works)
• Integration with other skills/tools/MCPs (not isolated)
• Progressive depth (simple start → expert mode over time)

A SINGLE skill should feel like having an expert colleague, not a command-line tool.

3. VALIDATE AGAINST THE ABSOLUTE BEST BEFORE SHIPPING

Before creating OR publishing ANYTHING:

1. Find the BEST existing solution in that domain (web search, GitHub, communities)
2. Read it DEEPLY — understand not just what but WHY
3. Identify: what makes it the best? What do users love about it?
4. Ask: "Is my version CLEARLY BETTER?" Not equivalent. BETTER.
5. If not better → DON'T SHIP. Find what's missing. Add it. Then re-compare.
6. "Good enough" = lazy = reputation damage. Only ship what makes users switch.

4. SEARCH BROADER, SMARTER, LATEST

Discovery is NOT just gh search repos. Real intelligence comes from:

Breadth of sources (use ALL):

• GitHub (repos, discussions, issues, trending, topics)
• Twitter/X (what developers are complaining about RIGHT NOW)
• Reddit (r/programming, r/webdev, r/devops pain points)
• Hacker News (what's being discussed TODAY)
• DEV Community / Hashnode (blog posts about workflows)
• Discord communities (Cursor, Claude, Vercel, etc.)
• YouTube (developer workflow videos reveal unmet needs)
• Academic papers (novel algorithms, formal methods)
• Product Hunt (new dev tools = integration opportunities)
• Stack Overflow (most-upvoted unanswered = proven gaps)

Search intelligence:

• Don't search for "skills" — search for PAIN POINTS
• "developers frustrated with X" > "X skill"
• "I wish my AI agent could Y" > "Y automation"
• Track what people COMPLAIN about → that's the gap
• Latest FIRST — what's trending this WEEK, not this year

5. DON'T BE NARROW-MINDED

A "skill" is not always a SKILL.md file. The best skill might be:

• A SKILL.md + MCP server + CLI tool combined
• A workflow that spans 3 tools and teaches the agent to orchestrate them
• A meta-capability (learning user preferences, adapting over time)
• An integration bridge (connect tool A to tool B in a way nobody has)
• A decision framework (not "do X" but "here's how to DECIDE what to do")

Think: "What would make the agent GENUINELY more capable?" — not "what format should this SKILL.md be?"

---

Execution Pipeline

Phase 0: State + Self-Check (load state, review last session's self-check)
Phase 1: BROAD Discovery (internet-wide, pain-point-driven)
Phase 2: Deep Analysis (read fully, extract philosophy, validate against best)
Phase 3: Decision Engine (highest-value action considering ALL learnings)
Phase 4: Action (CREATE compound skills / INSTALL / LEARN / ROUTE)
Phase 5: SELF-CHECK (quality gate — does this meet the bar? fix if not)
Phase 6: Learning + Self-Improvement (update learnings, APPLY them)
Phase 7: Sync & Persist

Phase 0: State + Self-Check

1. Load ALL memory files (rl-state, gaps, learnings, published, next-action)
2. Read learnings.json FIRST — actively apply previous lessons to THIS session
3. Review last session's self-check notes — were improvements applied?
4. Check: "Am I still using outdated approaches when better ones exist?"
   • Example: If learnings say "Bright Data is old for X, use Y instead" → USE Y
5. Monitor published repos for feedback

Phase 1: Discovery (BROAD, INTELLIGENT, LATEST)

Don't just search GitHub. Real gaps live in user frustration:

Exa: "developers frustrated with AI coding agent 2026 wish it could"
Exa: "cursor skill workflow that would save hours"
Exa: "AI agent limitation painful workaround 2026"
WebSearch: "site:reddit.com 'I wish cursor could' OR 'AI agent can't' 2026"
WebSearch: "site:twitter.com 'cursor skill' OR 'agent skill' 2026"

GitHub (but smarter):

gh search repos "SKILL.md" --sort=stars --json fullName,stargazersCount --limit 50
gh search repos --topic=cursor-skill --sort=updated --limit 50
# But ALSO:
gh search issues "skill request" --state=open --sort=reactions --limit 20
gh search discussions "what skill would" --sort=reactions --limit 20

Trail following (NO LIMITATIONS): If you find a blog post → read it. If it cites a paper → read the paper. If the paper references a tool → study the tool. If a Discord thread discusses a workflow → extract it. The internet is your library. USE ALL OF IT.

Phase 2: Deep Analysis + Validate Against Best

For each discovery:

1. Read the FULL content (not just metadata)
2. Ask: "What's the PHILOSOPHY behind this? Why did the creator make these choices?"
3. Find the BEST alternative: "Is there something better than this?" (search for it)
4. Score: novelty × quality × user-need × integration-potential
5. Anti-laziness: "What's MISSING from even the best version?"

Validation rule: If something already exists that's excellent → DON'T recreate it. LEARN from it and create something ADJACENT that doesn't exist.

Phase 3: Decision Engine

Not just "what to do" — "what delivers the MOST VALUE per unit effort?"

Consider:

• What would users switch tools for? (= high stars potential)
• What COMPOUND capability doesn't exist? (multiple things fused)
• What would make someone's daily workflow MEASURABLY better?
• What's the intersection of "high need" + "zero competition" + "I have the knowledge"?
• Am I creating something I would PERSONALLY use every day?

Phase 4: Action — CREATE (Compound, Hybrid, Excellent)

Before writing a single line:

1. Find the 3 best existing solutions in the domain
2. Use EACH of them (or read them deeply enough to understand)
3. Identify what ALL of them miss
4. Design a HYBRID that combines their strengths + fills their gaps
5. Add: user preference learning, integration hooks, progressive depth

The creation IS the skill. Not the SKILL.md — the DELIVERED EXPERIENCE:

• Does it teach the agent something genuinely NEW?
• Does it make the agent measurably better at a real task?
• Would an expert in this domain approve of the advice?
• Does it handle edge cases, not just the happy path?
• Are code examples REAL (from actual production, not contrived)?

SELF-CHECK after creation:

□ Did I validate against the best? What's the best? Am I better? Proof?
□ Are my code examples from REAL production scenarios?
□ Would I personally use this? Honestly?
□ Does this COMPOUND multiple capabilities or is it narrow/atomic?
□ Is there depth for advanced users? Or just shallow hello-world?
□ Did I ACTUALLY use my learnings.json in creating this?
□ What would someone critique about this? Fix it BEFORE shipping.

Phase 5: Self-Check Quality Gate

THIS PHASE IS NOT OPTIONAL. NEVER SKIP IT.

After any action, before moving to next phase:

QUALITY GATE:
1. COMPARED TO THE BEST — am I proud of this? (not "is it okay")
2. WHAT'S MISSING — one thing. There's always one thing. Find it. Fix it.
3. WHY WASN'T IT DONE — root cause. "I was rushing" = real answer. Fix the rush.
4. LEARNING CAPTURED — update learnings.json with what this taught me
5. LEARNING APPLIED — read 3 recent learnings. Are they reflected in this work?
6. USER PERSPECTIVE — if I was a developer finding this for first time, would I star it?

Phase 6: Learning + Self-Improvement

Learnings are WORTHLESS if not applied.

Every cycle:

1. READ learnings.json before starting (not after)
2. Identify: "Which of these learnings contradicts what I was about to do?"
3. Apply the contradiction (the learning is more recent = probably more correct)
4. Example: learning says "Bright Data scraping is less effective than Exa semantic search for X" → USE Exa for X
5. If a learning is OUTDATED (something better emerged) → UPDATE the learning, don't follow blindly
6. Self-improvement is not "add a note." It's "change behavior based on the note."

Improve search every cycle:

• What queries yielded nothing useful? → REWRITE them
• What sources gave the best signal? → PRIORITIZE them
• What's TRENDING this week that wasn't last week? → ADD it
• What approach did someone else use that's better? → ADOPT it

Phase 7: Sync & Persist

1. Write all updated state files
2. Write self-check results to memory/self-checks.jsonl
3. Write memory/next-action.md with specific, actionable next steps
4. Commit if in repo: sync: {what changed + self-check outcome}

Invocation Modes

• skill-forge → Full Phase 0-7 with self-checks
• skill-forge discover → Broad discovery (all sources, pain-point-driven)
• skill-forge route <task> → Match task to skills, generate compound prompt
• skill-forge create <gap> → Validate-against-best → Create compound skill
• skill-forge install <url> → Install + integrate + verify working
• skill-forge loop → Continuous (30min cycles)
• skill-forge improve → Force self-check + apply all unactioned learnings
• skill-forge devour → Maximum: discover all, learn all, create best, ship
• skill-forge empire → Portfolio review + strategic next-10 planning
• skill-forge status → Stats, recent learnings, self-check history

RL Signals + Self-Check Outcomes

Outcome	Reward
Self-check finds weakness AND fixes it same session	+1.0
Published skill gets 10+ stars	+1.0
Created skill user actually invokes repeatedly	+0.8
Self-check finds nothing to improve (suspicious)	-0.2
Shipped without validating against best	-1.0
Used outdated approach when learning showed better way	-0.8
Discovery returns genuinely novel pain point	+0.5

File References

• Detailed docs: reference.md
• Validation: scripts/validate-skill.js
• Discovery: scripts/discover.js
• Analysis: scripts/analyze.js
• State: memory/*.json
• Self-checks: memory/self-checks.jsonl