⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

skill-forge

3bdallaha7md@3bdallaha7md⭐ 2 stars· last commit 1mo ago· 0 open issues

>

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 2 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

⚙️ skill-forge - Improve AI Skills Automatically

Download skill-forge


🧩 What is skill-forge?

skill-forge is a tool that helps AI improve itself without human help. It changes the instructions AI uses to complete tasks, tests if these changes make things better, then keeps the good ones. If a change makes things worse, it goes back to the previous version. This loop helps AI get smarter on its own.

This project is inspired by ideas from Andrej Karpathy about how AI can learn by testing itself again and again. skill-forge works by running experiments on skills, tracking results, and managing improvements autonomously.


📋 Features and Key Points

  • Automatic skill improvement
    The system tests and refines AI instructions by itself.

  • Objective testing
    Changes are tested based on clear, measurable goals.

  • No human intervention
    The process runs on its own from start to finish.

  • Skill mutation and evaluation
    The AI agent changes skill instructions and checks the impact automatically.

  • Version control for skill changes
    Keeps improvements and discards bad changes to avoid setbacks.

  • Supports AI agents and large language models (LLMs)
    Works with various AI tools and models commonly used in research and development.


🖥️ System Requirements

To run skill-forge on Windows, make sure you have the following:

  • Windows 10 or later (64-bit recommended)
  • At least 8 GB of RAM
  • 4 CPU cores or higher for faster processing
  • Minimum 5 GB of free disk space
  • An active internet connection (for download and updates)
  • Python 3.8 or higher installed (requires Windows environment variable setup)

You do not need programming knowledge, but basic computer skills help with installation.


🚀 Getting Started: Download and Install

To start with skill-forge, follow these steps carefully:

Step 1: Download the software

Use the main download link below to visit the skill-forge page on GitHub. This page contains all the files you need to get the program working on your computer.

Download skill-forge from GitHub

Click the green Code button, then select Download ZIP to save the full package, or look in the Releases section for ready-to-run files.

Step 2: Extract the files

Once the ZIP file downloads, right-click on it and choose Extract All. Select a folder you can find easily, for example, on your Desktop or in your Documents.

Step 3: Install Python (if needed)

skill-forge requires Python. Check if Python is installed by:

  • Press the Windows Key + R to open Run
  • Type cmd and press Enter to open Command Prompt
  • Type python --version and press Enter

If you see a version number 3.8 or higher, you have Python installed.
If not, visit https://www.python.org/downloads/ to download and install Python. During installation, choose the option Add Python to PATH.

Step 4: Install required Python packages

Open Command Prompt again:

  • Navigate to the folder where you extracted skill-forge
    Example: cd Desktop\skill-forge-master
  • Run this command to install required packages:
    pip install -r requirements.txt
    

This downloads all software libraries skill-forge needs to run.

Step 5: Run skill-forge

In the same folder, type:

python skill_forge.py

This will start the program. Follow on-screen instructions to use the tool for skill improvement experiments.


🔧 How to Use skill-forge

skill-forge runs experiments where an AI agent changes its instructions and tests if the changes help. Here is a basic workflow:

  1. Define a skill
    Input instructions that describe a task you want the AI to improve.

  2. Set objective metrics
    Provide clear goals — for example, accuracy or speed that skill-forge measures.

  3. Start the iteration
    The system changes instructions slightly and runs the task.

  4. Evaluation
    Results are checked against the metrics.

  5. Decide keep or revert
    Improvements are saved. If not better, skill-forge goes back.

  6. Repeat automatically
    This cycle continues until you stop the process.

You can customize skill instructions and metrics by editing simple text files provided in the program folder.


🔄 Updating skill-forge

Check the GitHub page regularly to see if new versions are available. Download the latest files, extract, and follow the installation steps again.


❓ Troubleshooting

  • Python command not found: Make sure Python is installed and added to your system PATH. Restart your PC after installation.

  • Package installation errors: Check your internet connection and try pip install --upgrade pip before installing requirements.

  • Program does not run: Confirm you are in the correct folder in Command Prompt when running python skill_forge.py.

  • Errors about missing files: Extract the ZIP fully and do not run the script inside the ZIP file.

  • If errors continue: Share a screenshot and error message on the GitHub Issues page.


🔗 Resources


🔑 Keywords

agents, ai, automation, autonomous-agents, autoresearch, claude, engineering, enterprise-ai, eval, karpathy, llm, openclaw, overnight-training, prompt-engineering, self-improving, skills

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md7.9 KBupstream ↗
    ---
    name: skill-forge
    description: >
      Autonome Verbesserung nach dem Autoresearch-Paradigma (Karpathy). Zwei Modi:
      (1) Skill-Modus — optimiert eine SKILL.md durch iterative Mutation und Evaluation.
      (2) Generic-Modus — optimiert beliebige Dateien gegen jede mechanische Metrik
      (Testabdeckung, Bundle-Size, Lighthouse-Score, Docker-Image-Größe, etc.).
      Zwei Ausführungsmodi: Auto (vollautonomer Loop, ideal für Overnight-Runs) und
      Guided (interaktiv, User entscheidet bei jedem Schritt mit). Führt einen
      Experiment-Loop durch: analysieren → Hypothese bilden → mutieren → verifizieren →
      Score messen → keep/revert → wiederholen. Kann über Nacht als Scheduled Task
      laufen und liefert morgens einen Experiment-Report. IMMER verwenden bei: Skill
      autonom verbessern, Skill optimieren ohne manuelles Feedback, Skill optimieren
      mit Feedback, Autoresearch, autonomer Verbesserungsloop, Skill-Evolution,
      overnight optimization, Skill-Experiment, "lass den Skill über Nacht besser
      werden", Skill-Score verbessern, automatische Skill-Iteration, Code-Metrik
      verbessern, Testabdeckung erhöhen, Bundle-Size reduzieren, Performance-Score
      optimieren, beliebige Metrik optimieren, "hilf mir den Skill zu verbessern",
      Skill interaktiv verbessern, geführte Optimierung.
    ---
    
    # Skill Forge
    
    Iterative Verbesserung nach dem Autoresearch-Paradigma: Ein AI-Agent modifiziert
    gezielt Dateien, evaluiert jede Änderung gegen eine mechanische Metrik, behält
    Verbesserungen und verwirft Verschlechterungen.
    
    ## Ausführungsmodi
    
    | | Auto-Modus | Guided-Modus |
    |---|---|---|
    | **Ablauf** | Vollautonomer Loop ohne User-Eingriff | User entscheidet an jedem Checkpoint |
    | **Ideal für** | Overnight-Runs, Scheduled Tasks | Erstmalige Nutzung, Domänenwissen einbringen |
    | **Evals** | Automatisch generiert | User prüft und passt an |
    | **Hypothesen** | Automatisch umgesetzt | User sieht Vorschlag, kann ablehnen/anpassen |
    | **Mutationen** | Automatisch angewendet | User sieht Diff, bestätigt oder korrigiert |
    | **Keep/Revert** | Automatisch nach Schwellenwerten | User entscheidet mit Score als Empfehlung |
    | **Wann wählen** | Vertrautes Setup, bewährte Evals | Neuer Skill, unsichere Evals, Lernmodus |
    
    Der Wizard fragt als ersten Schritt: **"Auto oder Guided?"**
    
    Im Guided-Modus gibt es 5 Checkpoints, an denen der User einbezogen wird:
    
    1. **Evals prüfen** — User sieht generierte Evals, kann anpassen/ergänzen/streichen, Anzahl und Gewichtung bestimmen
    2. **Hypothese prüfen** — User sieht die Hypothese und kann sie ablehnen, anpassen oder eine eigene Richtung vorgeben
    3. **Mutation prüfen** — User sieht das Diff vor Anwendung und bestätigt
    4. **Ergebnis bewerten** — User sieht Score + Delta und entscheidet: Keep, Revert oder manuell anpassen
    5. **Weitermachen?** — User entscheidet ob eine weitere Runde laufen soll oder der Loop endet
    
    Im Auto-Modus werden alle 5 Checkpoints übersprungen und die Entscheidungen
    automatisch nach den konfigurierten Schwellenwerten getroffen.
    
    ## Zwei Domänen-Modi
    
    | | Skill-Modus | Generic-Modus |
    |---|---|---|
    | **Ziel** | SKILL.md verbessern | Beliebige Dateien optimieren |
    | **Metrik** | Composite Score (Assertions + Judge + Effizienz) | Jede mechanische Metrik (Zahl via Shell-Command) |
    | **Scope** | Eine SKILL.md + zugehörige Scripts | Dateien via Glob-Pattern |
    | **Mutation** | Sprachliche Änderungen (Formulierung, Beispiele, Struktur) | Code-Änderungen (Refactoring, Config, Architektur) |
    | **Eval** | Subagent-Runs mit Grading | Shell-Command mit Zahlenextraktion |
    | **Anwendung** | Skill-Qualität steigern | Testcoverage, Bundle-Size, Lighthouse, Docker-Image, etc. |
    
    Der Skill erkennt den Modus automatisch: Wenn der User einen Skill nennt, wird
    Skill-Modus aktiviert. Wenn der User eine Metrik/einen Shell-Command nennt, wird
    Generic-Modus aktiviert. Im Zweifel: fragen.
    
    ## Kern-Konzept
    
    Inspiriert von Karpathys autoresearch-Paradigma:
    
    | autoresearch (LLM)        | autoresearch (Skills/Generic)  |
    |---------------------------|-------------------------------|
    | `train.py` wird mutiert   | `SKILL.md` / Scope-Dateien werden mutiert |
    | `prepare.py` ist fix      | Eval-Framework / Verify-Command ist fix |
    | `program.md` instruiert   | Dieser Skill instruiert       |
    | `val_bpb` ist die Metrik  | Composite Score / mechanische Metrik |
    | 5-Min-Zeitbudget          | Token/Zeit-Budget pro Eval    |
    | keep/discard              | keep/revert mit Snapshots     |
    
    ---
    
    ## Schritt 0: Setup-Wizard (einmalig)
    
    Der Setup-Wizard führt schrittweise durch die Konfiguration. Jeder Schritt hat ein
    Abnahmekriterium — der Wizard geht erst weiter, wenn die Validierung bestanden ist.
    
    ### Wizard-Schritt 1: Ausführungsmodus, Domänenmodus und Ziel erfassen
    
    Frage den User zwei Dinge:
    
    **1. "Auto oder Guided?"**
    - **Auto**: "Ich lasse den Loop laufen und schaue mir morgens den Report an"
    - **Guided**: "Ich will bei jedem Schritt mitentscheiden"
    - Bei Scheduled Tasks: Immer Auto (Guided nicht möglich ohne User)
    
    **2. "Was willst du verbessern?"**
    
    Bestimme daraus den Domänenmodus:
    - User nennt einen Skill-Namen → **Skill-Modus**
    - User nennt eine Metrik, einen Shell-Command oder Code-Dateien → **Generic-Modus**
    - Unklar → Nachfragen
    
    Speichere:
    ```json
    {
      "execution_mode": "auto" | "guided",
      "mode": "skill" | "generic",
      "goal": "Freitext-Beschreibung des Ziels",
      "target": "Skill-Name oder Projekt-Pfad"
    }
    ```
    
    ### Wizard-Schritt 2: Scope definieren
    
    **Skill-Modus:**
    - Identifiziere die SKILL.md des Target-Skills
    - Validierung: Datei existiert und ist lesbar
    
    **Generic-Modus:**
    - Frage nach Glob-Pattern für editierbare Dateien (z.B. `src/**/*.ts`)
    - Validierung: Glob matcht mindestens eine Datei
    - Anzeigen: "Gefunden: N Dateien — [Liste der ersten 10]"
    - Falls 0 Treffer → Fehlermeldung, neues Pattern verlangen
    
    Speichere:
    ```json
    {
      "scope": "SKILL.md-Pfad oder Glob-Pattern",
      "scope_files_count": 42,
      "scope_validated": true
    }
    ```
    
    ### Wizard-Schritt 3: Metrik definieren
    
    **Skill-Modus:**
    - Prüfe ob `evals/evals.json` existiert im Target-Skill
    - Falls nicht: Erstelle 3-5 realistische Testfälle mit messbaren Assertions
    - Achte auf Train/Test-Split (60/40) für Overfitting-Schutz
    - Metrik = Composite Score (automatisch)
    
    **🔀 Guided-Checkpoint 1: Evals prüfen (nur Skill-Modus)**
    
    Im Guided-Modus: Zeige dem User die generierten/vorhandenen Evals und frage:
    - "Das sind die Testfälle. Passen sie?"
    - User kann: Evals anpassen, neue hinzufügen, Gewichtung ändern, Anzahl bestimmen
    - User kann auch beschreiben: "Ich will dass besonders X getestet wird"
    - Erst nach User-Bestätigung wird der Train/Test-Split durchgeführt
    
    **Generic-Modus:**
    - Frage: "Welcher Shell-Command misst deine Metrik?"
    - Beispiele anbieten:
      - Testabdeckung: `npx jest --coverage | grep "All files" | awk '{print $10}'`
      - Bundle-Size (KB): `npm run build 2>&1 | grep "First Load JS" | awk '{print $4}'`
      - Lighthouse: `npx lighthouse http://localhost:3000 --output json | jq '.categories.performance.score'`
      - Docker-Image (MB): `docker image inspect myapp:latest --format '{{.Size}}' | awk '{print $1/1048576}'`
      - Python-Lint-Fehler: `flake8 src/ | wc -l`
    - Validierung: Subjektive Metriken ("sieht besser aus", "klingt natürlicher") werden abgelehnt.
      Die Metrik muss eine einzelne parsbare Zahl produzieren.
    - Hinweis: Der Metrik-Parser extrahiert die **letzte Zahl** im Command-Output.
      Falls der Command Fortschrittsmeldungen oder Zeilennummern ausgibt, sollte
      der User den Output so filtern, dass nur die relevante Zahl am Ende steht
      (z.B. mit `| tail -1` oder `| grep "Score"`).
    
    
    Speichere:
    ```json
    {
      "metric_name": "test_coverage_percent",
      "metric_command": "npx jest --coverage | grep 'All files' | awk '{print $10}'",
      "metric_direction": "higher_is_better" | "lower_is_better"
    }
    ```
    
    ### Wizard-Schritt 4: Richtung festlegen
    
    Frage: **"Ist ein höherer oder niedrigerer Wert besser?"**
    
    - Testabdeckung → höher ist besser
    - Bundle-Size → niedriger ist besser
    - Lint-Fehler → niedriger ist besser
    - Per
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/3bdallaha7md-skill-forge.md

// REPO STATS

2 stars
0 open issues
Last commit: 1mo ago