Skip to content
Skills Library
AI & agents · Research

skill-forge

/skill-forge

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.

Repository
skill-forge ↗
Licence
MIT
Last repository change
28.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
12
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 28.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Original author 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.

How it works

  1. Two Objectives (everything serves these)
  2. Core Principles
  3. What This Skill Does For The User
  4. Execution Pipeline
  5. Phase 0: State + Apply Learnings
  6. Phase 1: Discovery (Broader Than You Think)
  7. Phase 2: Deep Analysis
  8. Phase 3: Decision Engine
  9. Phase 4: Actions
  10. Phase 5: Self-Check + SkillOpt
Original SKILL.md headings · 354 lines, 2,484 words
SKILL.md preview
---
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)

| Sub-Objective | Serves |
|--------------|--------|
| Find + use best skills for ANY project the user works on | Self-improvement + user value |
| List + advertise published skills across all platforms | Reputation |
| Optimally select approaches for hackathons, industry, creativity | Self-improvement + creation quality |
| Help implement learnings in ALL future projects | User value |
| Better creative thinking, project guidance, architecture | Self-improvement + skill depth |
| Make devouring faster and more efficient each cycle | Self-improvement (meta) |
| Learn from every novel approach encountered anywhere | 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:
```json
{
  "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:

| Action | Serves Self-Improvement | Serves Reputation | Serves User |
|--------|------------------------|-------------------|-------------|
| Create new skill | If novel approach | If it gets stars | If it solves their problem |
| Install existing skill | Faster routing | — | Direct value |
| Learn pattern | Improves future cycles | Improves creation quality | Applies to their projects |
| Route to skill | — | — | Immediate value |
| Promote published skill | — | Direct stars | — |
| Guide project/architecture | Learnings applied | Reputation from quality | Direct value |

**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):**
```bash
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:**
```json
{
  "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

| Outcome | Reward | Which Objective |
|---------|--------|-----------------|
| Self-check finds AND fixes weakness same session | +1.0 | Self-improvement |
| Published skill gets 10+ stars | +1.0 | Reputation |
| User invokes a routed skill successfully | +0.8 | User value |
| Cycle was FASTER than previous | +0.5 | Self-improvement (meta) |
| Promotion leads to install | +0.5 | Reputation |
| Learning applied in user's project successfully | +0.8 | User value |
| Shipped without validating against best | -1.0 | Reputation |
| Cycle was SLOWER than previous (regression) | -0.5 | Self-improvement |
| Learning stored but never applied | -0.3 | Both (waste) |

## File References

- Docs: [reference.md](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/`
Files in this package (12)
  • .gitattributes 1 KB
  • .gitignore 1 KB
  • AGENTS.md 4 KB
  • CHANGELOG.md 3 KB
  • CLAUDE.md 2 KB
  • CONTEXT.md 3 KB
  • CONTRIBUTING.md 3 KB
  • LICENSE 1 KB
  • README.md 9 KB
  • SKILL.md 17 KB
  • package.json 2 KB
  • reference.md 6 KB

Versions

RepositoryScoreLicence
This page · Adit-Jain-srm/skill-forge100MIT
tonydzi/second-brain-starter-kit100MIT
frankxai/starlight-intelligence-system100MIT
antoniocascais/claude-code-toolkit100AGPL-3.0
sanyuan0704/sanyuan-skills100MIT
mphinance/alpha-skills98MIT
devpilotX/ai-skill-ai98MIT
rune-kit/rune95MIT
davidsouther/ailly90MIT

Database snapshot: 13.11.2026 · package version c2a5e042564b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95creating-agent-skills
    Expert guidance for creating, writing, and refining Claude Code Skills. Use when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.
  • 95creating-agent-skills
    Create and refine Claude Code Skills. Use when authoring SKILL.md files, building new skills, or improving existing skill structure and best practices.
  • 95creating-agent-skills
    Expert guidance for creating, writing, and refining Claude Code Skills. Use when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.
  • 100create-agent-skills
    Expert guidance for creating agent skills and slash commands. Use when working with SKILL.md files, authoring new skills, improving existing skills, creating slash commands, or understanding skill structure and best practices.
  • 100create-agent-skills
    Expert guidance for creating, writing, building, and refining Claude Code Skills. Use when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.
  • 100create-agent-skills
    Expert guidance for creating Claude Code skills and slash commands. Use when working with SKILL.md files, authoring new skills, improving existing skills, creating slash commands, or understanding skill structure and best practices.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.