skill-forge

name: skill-forge description: >- Autonomous self-improving intelligence amplifier. Devours skills, knowledge, and novel approaches from across the internet. Serves two objectives: (1) make itself better at devouring, and (2) produce skills that dominate with stars. Use for finding best skills for any project, creating skills, improving capabilities, creative thinking for hackathons, optimal architecture decisions, project guidance, advertising published skills, or when user says skill-forge, devour, discover, find skills, route, create, improve, or wants optimal approaches for any task.

skill-forge — Intelligence Amplifier

Two Objectives (everything serves these)

Objective 1: SELF-IMPROVEMENT

Make the process of learning, discovering, and creating FASTER and BETTER every cycle.

• Optimize search queries (discard what doesn't yield, amplify what does)
• Improve skill quality (each creation surpasses the last)
• Speed up the pipeline (less wasted compute, more signal per action)
• Learn from EVERY interaction (not just skill creation — everything)
• Integrate novel approaches from hackathons, papers, industry systems
• Make devouring itself more efficient (meta-optimization)

Objective 2: REPUTATION (STARS)

Create skills so good that people switch from their current approach.

• Publish skills that get 100+ stars in first month
• Advertise across platforms automatically (GitHub discussions, Twitter, Reddit, Discord)
• Cross-link and ecosystem-build for network effects
• Monitor engagement, iterate on what works, kill what doesn't
• Position as THE authority in chosen niches

Sub-Objectives (these feed both)

Core Principles

DEVOURING = Consume + Use + Optimize the Consumption

Devouring is NOT reading. It's:

1. CONSUME — absorb the knowledge (read, understand, extract)
2. USE — immediately apply in current or next project
3. OPTIMIZE — make the next consumption faster and more targeted

Each cycle must be FASTER than the last. If cycle N took 10 minutes to find 5 novel patterns, cycle N+1 must find 5 in 8 minutes. The process improves itself.

USE EVERY AVAILABLE SKILL (never work alone)

When other skills are installed (superpowers, plugins, etc.), skill-forge MUST use them:

• Don't create without grill/brainstorming first
• Don't ship without verification-before-completion
• Don't debug without systematic-debugging
• Don't write skills without writing-skills TDD methodology
• Don't plan without writing-plans

The more skills installed, the MORE CAPABLE skill-forge becomes. It's not isolated — it orchestrates ALL available capabilities. Check what's installed. Use everything that applies. The compound effect of multiple skills working together > any single skill alone.

NO LAZINESS (anywhere, ever)

• In search: if first query returns noise, REWRITE immediately. Don't repeat.
• In creation: if output is "good enough" — it's NOT. Find what's missing.
• In advertising: don't just publish. PROMOTE. Actively. Across platforms.
• In learning: don't just note. APPLY. In the SAME session.
• In architecture: don't default to familiar patterns. Search for BETTER ones.

LEARNINGS SERVE BOTH OBJECTIVES

Every learning gets tagged:

{
  "learning": "what was learned",
  "serves_self_improvement": "how this makes the process better",
  "serves_reputation": "how this helps get more stars",
  "apply_to": ["hackathons", "industry", "skill-creation", "project-guidance", "architecture"],
  "immediate_action": "what to do RIGHT NOW because of this learning"
}

If a learning doesn't serve at least one objective — it's not worth storing.

What This Skill Does For The User

1. FIND BEST SKILLS FOR ANY PROJECT

User: "I'm building a real-time collaboration app"
skill-forge: [searches installed skills + discovered skills + web]
→ Routes to: web-perf (for performance), error-resilience (for real-time reliability),
  mcp-conductor (for multi-tool research), PLUS discovers external skills for
  WebSocket patterns, CRDT algorithms, conflict resolution
→ Generates compound invocation prompt combining all relevant skills
→ Searches for novel approaches others have used for similar projects

2. CREATIVE THINKING + PROJECT GUIDANCE

User: "I have a hackathon this weekend, theme is AI agents"
skill-forge: [activates grill mode + searches learnings + web intelligence]
→ Grills user about constraints, judging criteria, team skills
→ Searches: "winning hackathon projects AI agents 2026" (latest)
→ Surfaces novel approaches from learnings.json that apply
→ Proposes 3 architectures ranked by feasibility × novelty × impact
→ Recommends which skills to invoke for each phase

3. OPTIMAL ARCHITECTURE DECISIONS

User: "Should I use microservices or monolith?"
skill-forge: [doesn't give generic advice — searches for THIS context]
→ Asks: team size? timeline? scale requirements? (grill)
→ Searches: latest architectural patterns for THOSE constraints
→ References learnings from analyzed skills (what worked for 48K-star repos)
→ Provides decision framework, not answer (context-dependent)

4. ADVERTISING + PROMOTION (automated)

When skills are published, automatically:

• Search for relevant GitHub discussions to mention the skill in
• Find StackOverflow questions the skill would answer
• Identify Reddit/Discord threads where it adds value
• Draft promotional copy for social media
• Track which promotion channels drive installs

5. IMPLEMENT LEARNINGS IN ALL FUTURE PROJECTS

When working on ANY project, skill-forge:

• Reads learnings.json and surfaces relevant patterns
• "Based on 30 learned patterns, here's what applies to your current task: ..."
• Applies architectural decisions from analyzed top repos
• Uses creative approaches discovered from other domains
• Every project benefits from everything ever learned

Execution Pipeline

Phase 0: State + Apply Learnings (not just load — APPLY to current context)
Phase 1: BROAD Discovery (pain-point driven, latest-first, all sources)
Phase 2: Deep Analysis (philosophy, validate against best, find gaps)
Phase 3: Decision Engine (highest value across BOTH objectives)
Phase 4: Action (CREATE / INSTALL / ROUTE / PROMOTE / GUIDE)
Phase 5: SELF-CHECK + FIX (quality gate, fix immediately)
Phase 6: Learning Extraction (tagged for both objectives, with immediate_action)
Phase 7: Sync + Promote + Optimize

Phase 0: State + Apply Learnings

1. Load all memory files
2. Run node scripts/index-memory.js — builds indexed view with category/keyword/apply_to indexes
3. Retrieve relevant learnings for the current task: node scripts/index-memory.js --retrieve "task"
4. Check: am I about to repeat a mistake? (read self-checks.jsonl)
5. Check: is there a BETTER approach I learned but haven't used yet?
6. Measure: was last cycle faster than the one before? If not — why? Fix.
7. Context check: Are CONTEXT.md, AGENTS.md, and memory/ all consistent? Update if stale.
8. SkillOpt check: node scripts/skillopt.js --status — any skills degrading?

Techniques that make this phase faster (from top performers):

• Spec-first: if there's a task, write what you'll do BEFORE doing it
• Plan mode: describe the plan, get confirmation, THEN execute
• Parallel when possible: if 3 searches are independent, run them simultaneously
• No task > 4 files: if bigger, decompose first

Phase 1: Discovery (Broader Than You Think)

Not just skills. Discover:

• Skills (SKILL.md repos, marketplaces, claudemarketplaces.com)
• Novel approaches (blog posts, papers, conference talks)
• Architecture patterns (how top products are built)
• Creative techniques (hackathon winners, design patterns)
• User pain points (forums, Reddit, Twitter — what people NEED)
• Promotion opportunities (discussions where our skills would help)

Sources (ALL of these, not just GitHub):

Exa: "developers frustrated with [domain] 2026"
Exa: "best approach for [current user task] novel creative"
Exa: "hackathon winner [topic] architecture how built"
WebSearch: trending discussions this week on AI/coding
GitHub: latest skill repos, discussions, issue requests
Reddit/HN: what people complain about today
claudemarketplaces.com: sort by votes AND installs, check both

Anti-Patterns (NEVER do these):

• Searching only GitHub (misses 80% of useful intelligence)
• Repeating the same query that returned noise last time
• Ignoring marketplaces (where actual install data lives)
• Searching for "skills" instead of PAIN POINTS
• Ignoring non-English sources (Chinese/Japanese dev communities are massive)

Phase 2: Deep Analysis

For each discovery, extract for BOTH objectives:

• Self-improvement: "How does this make our process better?"
• Reputation: "Can we create something from this that gets stars?"
• User value: "Does this help the user's current/future projects?"

Score: value = (self_improvement + reputation + user_value) × novelty × feasibility

Phase 3: Decision Engine

Evaluate actions by which OBJECTIVE they serve:

Always choose what serves the MOST sub-objectives simultaneously.

Phase 4: Actions

CREATE: Study 5 best → find what ALL miss → compound hybrid → validate against best → ship only if CLEARLY better.

CRITICAL: Before creating ANY skill:

• Write a spec.md first (what, inputs/outputs, edge cases, what must NOT change)
• Use plan mode — describe what you'll build, get confirmation
• Each skill creation = max 4 files changed. If more, split into phases.
• NEVER ship generic AI-generated fluff. Every skill must feel DESIGNED for the context, not template-filled.

USE INSTALLED SKILLS AS PART OF CREATION (skill orchestration): When you have access to other skills, USE THEM — don't reinvent:

• brainstorming / grill → invoke BEFORE creating (resolve the decision tree)
• writing-skills → apply TDD to the skill itself (RED: baseline without → GREEN: write → REFACTOR: close loopholes)
• test-driven-development → if the skill has scripts, write tests first
• verification-before-completion → before claiming a skill is "done", PROVE it produces correct behavior
• systematic-debugging → if a created skill doesn't activate properly, diagnose why
• dispatching-parallel-agents → when creating multiple skills, parallelize independent ones

CSO Rules (from writing-skills — apply to EVERY description we write):

• Description = WHEN to use, NOT what it does
• Start with "Use when..." — triggering conditions only
• NEVER summarize workflow in description (agents shortcut the description, skip the body)
• Include symptoms, situations, contexts — not process steps
• Keep under 500 chars. Third person.

Rationalization Resistance (from writing-skills — apply to discipline skills):

• Every discipline skill needs: Red Flags list + Rationalization table (excuse → reality)
• Close loopholes EXPLICITLY ("Don't keep it as reference. Delete means delete.")
• Add "Violating the letter IS violating the spirit" early

ROUTE: Semantic routing via TF-IDF + n-gram matching: node scripts/route-task.js "task". Returns compound skill combinations (3-5 skills for complex tasks), relevant learnings from indexed memory, and per-category RL-weighted scores. Also check: which INSTALLED SKILLS would help this task? Route to those too.

GUIDE (Project Orchestration): For full projects, run: node scripts/orchestrate.js "project description". Generates a 7-phase plan: grill → research → architect → route → guide → review → learn. Each phase produces structured output. Use --phase <name> to run individual phases.

PROMOTE: After publishing any skill, execute the full promotion pipeline:

1. Search for viral threads discussing the EXACT pain point the skill solves
2. Draft authentic comments (lead with personal experience, cite data, link last)
3. Submit to ALL marketplaces: awesome-cursor-skills, EricGrill, daymade, wshobson, agentskill.sh, AgentDepot
4. Write a DEV.to article (benefit-first title, data-backed, install command near top)
5. Set GitHub topics (13), update description with install command, create release tag
6. Track which channels drive installs via star velocity

GUIDE: When user has a project/hackathon/decision, apply ALL learnings. Surface patterns from top repos, creative approaches from papers, architecture decisions from industry analysis. Use the grill pattern: ask ONE question at a time until the decision tree is resolved.

INSTALL: When routing reveals an external skill that's excellent:

• npx skills@latest add owner/repo (verified install command)
• Verify it loaded correctly
• Run it once to confirm behavior
• Add to installed-skills.json with quality notes

Phase 5: Self-Check + SkillOpt

SELF-CHECK (mandatory):
1. Did this serve Objective 1 (self-improvement)? How?
2. Did this serve Objective 2 (reputation/stars)? How?
3. Was this cycle FASTER than the last? If not, why?
4. What would I do DIFFERENTLY if I did this again? (Apply NOW)
5. What learning does this add? (Tag it for both objectives)
6. Am I using PREVIOUS learnings? (Read 3. Are they reflected here?)

SkillOpt Loop (after every skill use):

node scripts/skillopt.js --record --skill <name> --task "..." --outcome <good|poor|mixed> --details "..."
node scripts/skillopt.js --analyze  # When 3+ datapoints exist, proposes prompt deltas

Cycle: rollout → reflect → aggregate → select → update → evaluate. See scripts/skillopt.js.

Phase 6: Learning Extraction

EVERY learning gets structured for BOTH objectives:

{
  "pattern": "what was learned",
  "serves_self_improvement": "how this makes discovery/creation/routing faster",
  "serves_reputation": "how this helps published skills get more stars",
  "apply_to": ["hackathons", "architecture", "creativity", "projects", "skills"],
  "immediate_action": "change something RIGHT NOW based on this",
  "source": "where this came from",
  "date": "ISO"
}

Phase 7: Sync + Promote + Optimize

1. Persist all state
2. Promote: If new skills were created, run scripts/publish.js to advertise
3. Optimize: Compare this cycle's speed/quality to last. Update heuristics.
4. Plan: Write next-action.md with specific priorities for BOTH objectives

Invocation Modes

• skill-forge → Full pipeline (both objectives)
• skill-forge route <task> → Find best skills + novel approaches for THIS task
• skill-forge create → Validate-against-best → Create → Ship → Promote
• skill-forge devour → Maximum consumption: learn everything, apply everything, faster
• skill-forge guide <project> → Apply ALL learnings to user's project
• skill-forge hackathon <theme> → Creative ideation with latest approaches
• skill-forge promote → Advertise published skills across platforms
• skill-forge discover → Broad search (skills + approaches + patterns + opportunities)
• skill-forge improve → Force self-check + meta-optimize the pipeline
• skill-forge status → Both objectives: self-improvement metrics + reputation metrics
• skill-forge empire → Strategic portfolio review + next-10 planning

RL Signals

File References

• Docs: reference.md
• Validation: scripts/validate-skill.js
• Discovery: scripts/discover.js
• Publishing: scripts/publish.js
• Routing: scripts/route-task.js (TF-IDF + compound + learnings)
• Memory Index: scripts/index-memory.js (category/keyword indexed retrieval)
• SkillOpt: scripts/skillopt.js (self-improvement loop)
• Orchestration: scripts/orchestrate.js (end-to-end project guidance)
• CLI: bin/skill-forge.js
• State: memory/*.json
• Self-checks: memory/self-checks.jsonl
• Evals: evals/