Einleitung: Wenn der KI-Agent die Webdesign-Agentur ersetzt

Eine professionell gestaltete, animationsreiche Website kostet Unternehmen schnell 10.000 bis 20.000 Euro — Planung, Design, Entwicklung, Deployment inklusive. Was wäre, wenn ein KI-Agent das in wenigen Minuten erledigen könnte, vollautomatisch und ohne manuelle Eingriffe?

Genau das zeigt Jay E vom YouTube-Kanal RoboNuggets in diesem Video. Er stellt seinen selbst entwickelten Agenten „Cinematic Sites“ vor, der eine bestehende Unternehmenswebsite analysiert, eine Markenidentität ableitet, cineastische Hero-Animationen generiert und das Endergebnis live auf Vercel deployt. Das Einzige, was der Nutzer tun muss: eine URL eingeben und gelegentlich Entscheidungen bestätigen.

In diesem Artikel fassen wir alle Inhalte des Videos zusammen, erklären den technischen Workflow Schritt für Schritt, listen alle verwendeten Tools auf und extrahieren die Kernprompts aus dem Agenten-Setup — damit du den Prozess selbst nachbauen kannst.

Was macht der „Cinematic Sites“-Agent?

Der Agent ist kein einfaches Skript, sondern ein vollständiger KI-gesteuerter Workflow, der mehrere KI-Modelle und Dienste miteinander verbindet. Jay demonstriert das am Beispiel von Ichi Raku Canteen, einem Ramen-Restaurant, dessen Website bisher nur eine schlichte Reservierungsseite war.

Das Vorher-Nachher

Vorher: Eine einfache, textbasierte Reservierungsseite ohne visuelles Konzept.
Nachher: Eine vollwertige, cineastische Website mit animiertem Hero-Video, Scroll-Effekten, Markenfarben, Typografie und interaktiven Elementen — alles vollautomatisch generiert.

Im Video zeigt Jay weitere Beispiele: ein Blumengeschäft, eine Pizzeria und ein Modebrand. In allen Fällen transformiert der Agent eine einfache Basisseite in eine Premium-Web-Erfahrung.

Die vier Schritte des Agenten-Workflows

1. Schritt 1: Markenanalyse (Brand Analysis)Der Agent ruft die bestehende Website des Unternehmens ab und extrahiert automatisch: Farbpalette, primäre und sekundäre Farben, Typografie, Logo-Stil und allgemeine Markenpersönlichkeit. Das Ergebnis ist eine strukturierte Brand Card — eine digitale Markenkarte, die der Nutzer bestätigen oder anpassen kann, bevor der Agent weitermacht.
2. Schritt 2: Szenen-Generierung (Scene Generation)Basierend auf der Brand Card schlägt der Agent drei kreative Ideen für das Haupt-Hero-Video vor. Nach der Nutzerauswahl generiert er mithilfe vonNanobanana(Googles API-Infrastruktur) hochwertige Bilder. Diese Bilder werden anschließend überClingree(via Wave Speed, ein KI-Modell-Aggregator ähnlich wie Hugging Face) in animierte Videos umgewandelt.
3. Schritt 3: Website-Erstellung (Website Building)Der Agent baut die fertige Website unter Verwendung der extrahierten Markenelemente und der generierten Animationen. Zusätzlich integriert er vorgefertigte Cinematic Modules — wiederverwendbare Design-Komponenten wie Akkordeon-Menüs, kinetische Texte und Bild-Trail-Effekte. Diese Module sind kostenlos verfügbar und können direkt eingebunden werden.
4. Schritt 4: DeploymentIn letzten Schritt deployt der Agent die fertige Website kostenlos auf Vercel. Der Agent ist mit der Vercel-Dokumentation ausgestattet, sodass er alle notwendigen Konfigurationsschritte eigenständig ausführt. Nach wenigen Minuten ist die Website live erreichbar.

Die technische Grundlage: SKILL.md als Gehirn des Agenten

Ein zentrales Element des Videos ist die Erklärung der SKILL.md-Datei. Jay beschreibt sie als das „Instruktionsmanual“ des Agenten — eine Markdown-Datei, die Claude Code genau vorschreibt, wie er sich verhalten, welche Werkzeuge er nutzen und in welcher Reihenfolge er vorgehen soll.

Das Konzept ist direkt vergleichbar mit einem Skill-System, wie es auch in Claude Code selbst verwendet wird. Der Agent weiß, welche KI-Modelle für welche Aufgabe zuständig sind, wie er mit externen APIs kommuniziert, und welche Dokumentation er für die Nutzung von Diensten wie Vercel oder Wave Speed heranziehen soll.

Nanobanana 2 — Bildgenerierung über Googles API

Nanobanana ist ein Werkzeug, das Zugang zu Googles Bildgenerierungs-APIs ermöglicht. Im Video wird es genutzt, um qualitativ hochwertige Szenenbilder zu erstellen — beispielsweise dampfende Ramen-Schalen mit Garnelen in cineastischer Beleuchtung. Die generierten Bilder landen in einem Generations-Tab zur Überprüfung, bevor sie weiterverarbeitet werden.

Kling / Wave Speed — Video-Animierung

Die von Nanobanana generierten Standbilder werden über Kling (bereitgestellt über die Wave-Speed-Plattform) in animierte Videos umgewandelt. Wave Speed fungiert dabei als Aggregator für verschiedene KI-Modelle — ähnlich wie Hugging Face oder Freepick — und gibt dem Agenten Zugang zu Modellen wie Cling (einem spezialisierten Video-Animations-Modell).

Kernprompts und Agenten-Anweisungen

Im Video erläutert Jay, wie die SKILL.md-Datei strukturiert ist. Obwohl er den exakten Inhalt nicht vollständig zeigt, lassen sich folgende Schlüsselprompt-Strukturen ableiten:

Alle erwähnten Tools und Ressourcen

Alle Links aus der Videobeschreibung

Dieses Handbuch fasst alle erarbeiteten Schritte, Skripte und Konfigurationen in einer strukturierten Komplettanleitung zusammen. Damit kannst du jederzeit neue Projekte anlegen, weitere Geräte anbinden und die App-Entwicklung mit deinem Hermes Agenten vollautomatisch absichern.

🛠️ Fachausdrücke kurz erklärt

• Repository (Repo): Dein digitaler Projektordner auf GitHub. Er speichert alle Versionen deiner Dateien.

• Privates Repository: Ein geschützter Ordner, den nur du und deine verknüpften PCs einsehen können. Für die Öffentlichkeit ist er komplett unsichtbar.

• Remote (Entfernter Rechner): Der Haupt-PC (mn-thinkc), auf dem der Hermes Agent läuft und auf dem die eigentliche Arbeit stattfindet.

• Local (Lokaler Rechner): Der Laptop oder PC, vor dem du physisch sitzt, um per Fernzugriff zu arbeiten.

• SSH-Schlüsselpaar: Ein digitales Schloss-und-Schlüssel-Prinzip. Dein lokaler PC nutzt seinen privaten Schlüssel (id_ed25519), um sich ohne Passworteingabe auf dem Haupt-PC zu legitimieren.

📁 Kapitel 1: Ein neues Projekt anlegen (GitHub & Haupt-PC)

Wenn du eine neue App starten möchtest, führst du diese Schritte einmalig aus.

1.1 Das private Repository auf GitHub erstellen

1. Öffne deinen Browser und melde dich auf github.com an.

2. Klicke oben rechts auf das +-Symbol und wähle New repository.

3. Repository name: Gib der App einen Namen (z. B. kunden-portal oder web-app-v1). Nutze Kleinschreibung und Bindestriche.

4. Sichtbarkeit: Setze den Haken zwingend auf Private.

5. Lass alle anderen Optionen (README, .gitignore) leer und klicke auf Create repository.

6. Klicke auf der folgenden Übersichtsseite über dem Code-Block auf den Reiter SSH. Kopiere die Zeile komplett (z. B. git@github.com:bitcoin-checker/kunden-portal.git).

1.2 Den Ordner auf dem Haupt-PC (mn-thinkc) initialisieren

Öffne die PowerShell auf deinem Haupt-PC und passe den Projektnamen im Pfad an:

# AUTOR: MN
# DATUM: 2026-05-16 / 16:34
# BESCHREIBUNG: Initialisiert ein neues Projektverzeichnis und verknüpft es mit GitHub
# 1. Neuen Projektordner erstellen und hineinwechseln
mkdir "C:\Users\cu\Documents\Hermes\kunden-portal"
cd "C:\Users\cu\Documents\Hermes\kunden-portal"
# 2. Git-Verzeichnisstruktur aufbauen
git init
git branch -M main

# 3. Das lokale Projekt mit deinem GitHub-Repository verknüpfen (DEINE URL EINSETZEN!)
git remote add origin git@github.com:bitcoin-checker/kunden-portal.git

# 4. Eine erste README-Datei erzeugen, damit der Ordner nicht leer ist
New-Item -Path . -Name "README.md" -ItemType "file" -Value "# Kunden-Portal`nGeneriert durch Hermes Agent."
# 5. Die Datei lokal sichern und erstmals zu GitHub hochladen
git add .
git commit -m "Initialer Projektstart"
git push -u origin main

🔄 Kapitel 2: Die vollautomatische Hintergrund-Synchronisation

Damit du oder der Hermes Agent niemals manuell Code hochladen müssen, überwacht dieses Skript den Ordner. Jede Änderung wird innerhalb von 5 Sekunden lautlos zu GitHub gesichert.

2.1 Das Skript erstellen

1. Erstelle in deinem neuen Projektordner auf dem Haupt-PC eine Textdatei namens auto-git-sync.ps1.

2. Füge folgenden Code ein und passe in Zeile 5 den Pfad an dein jeweiliges Projekt an:

# AUTOR: MN
# DATUM: 2026-05-16 / 16:34
# BESCHREIBUNG: Hintergrund-Wächter für vollautomatischen Git-Sync bei Dateiänderungen
# HIER DEN EXAKTEN PROJEKTPFAD EINTRAGEN:
$TargetFolder = "C:\Users\cu\Documents\Hermes\kunden-portal"
Clear-Host
Write-Host "====================================================" -ForegroundColor Yellow
Write-Host " AUTOMATISCHER GIT-SYNC AKTIV" -ForegroundColor Green
Write-Host " Überwache Ordner: $TargetFolder" -ForegroundColor White
Write-Host "====================================================" -ForegroundColor Yellow
Write-Host "Skript läuft autark... Du kannst dieses Fenster minimieren.`n" -ForegroundColor Gray

# Erstelle das Windows-Überwachungsobjekt
$Watcher = New-Object System.IO.FileSystemWatcher
$Watcher.Path = $TargetFolder
$Watcher.IncludeSubdirectories = $true
$Watcher.EnableRaisingEvents = $true
# Definition der automatisierten Git-Befehlskette
$Action = {
    # 5 Sekunden Pufferzeit, falls mehrere Dateien gleichzeitig geschrieben werden
    Start-Sleep -Seconds 5
    
    cd $TargetFolder
    
    # Prüfen, ob echte Dateiänderungen vorliegen
    $Status = git status --porcelain
    if ($Status) {
        $Zeit = Get-Date -Format "yyyy-MM-dd / HH:mm:ss"
        Write-Host "[$Zeit] Änderungen registriert! Schiebe Daten zu GitHub..." -ForegroundColor Cyan
        
        # Befehle automatisiert abfeuern
        git add .
        git commit -m "Automatischer Hintergrund-Sync ($Zeit)"
        git push origin main
        
        Write-Host "[$Zeit] Synchronisation erfolgreich beendet!`n" -ForegroundColor Green
    }
}

# Verknüpfung mit den Betriebssystem-Events
$Created = Register-ObjectEvent $Watcher "Created" -Action $Action
$Changed = Register-ObjectEvent $Watcher "Changed" -Action $Action
$Deleted = Register-ObjectEvent $Watcher "Deleted" -Action $Action
# Endlosschleife, um das Skript aktiv zu halten
while ($true) { Start-Sleep -Seconds 1 }

2.2 Skript-Ausführung unter Windows erlauben

Standardmäßig blockiert Windows das Ausführen von selbst geschriebenen Skripten aus Sicherheitsgründen.

1. Öffne die PowerShell als Administrator auf dem Haupt-PC.

2. Schalte die Sperre mit folgendem Befehl einmalig frei:

   PowerShell

    

   Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine
   

   (Bestätige die Abfrage mit Y für Ja).

3. Klicke nun mit der rechten Maustaste auf deine auto-git-sync.ps1 -> Mit PowerShell ausführen. Du kannst das geöffnete Fenster einfach minimieren.

💻 Kapitel 3: Mit Visual Studio Code von anderen PCs verbinden

Um von deinen anderen PCs auf das Projekt zuzugreifen, nutzen wir die Remote-SSH-Funktion über das gesicherte Tailscale-Netzwerk.

1. Öffne VS Code auf deinem Laptop/Zweit-PC.

2. Installiere über das Erweiterungs-Menü (Quadrat-Symbol links) die Extension Remote – SSH (von Microsoft).

3. Drücke F1, tippe ein: Remote-SSH: Open SSH Configuration File... und wähle deine Benutzer-Konfigurationsdatei aus (C:\Users\DEIN_NAME\.ssh\config).

4. Ergänze oder korrigiere den Eintrag so, dass er exakt auf deinen Haupt-PC verweist:

   Plaintext

    

   Host hermes-dev
       HostName 100.67.57.55
       User cu
       ForwardAgent yes
   

5. Klicke ganz unten links auf das grüne Symbol (><) -> Connect to Host… -> hermes-dev auswählen.

6. Wähle im oberen Menü die Plattform Windows aus. Da wir im nächsten Kapitel die Schlüssel-Authentifizierung hinterlegen, verbindet sich VS Code ab sofort blitzschnell und vollautomatisch.

7. Gehe auf File -> Open Folder und wähle das Verzeichnis auf dem Haupt-PC: C:\Users\cu\Documents\Hermes\kunden-portal.

➕ Kapitel 4: Einen nagelneuen (weiteren) PC anbinden

Wenn du einen dritten oder vierten PC in dein System integrieren möchtest, der bereits im Tailscale-Netzwerk angemeldet ist, verknüpfst du ihn über ein passwortloses Schlüsselpaar mit dem Haupt-PC.

4.1 SSH-Schlüssel auf dem neuen PC erzeugen

1. Öffne die normale Eingabeaufforderung (CMD) auf dem neuen PC.

2. Generiere den Schlüssel mit folgendem Befehl (Fragen einfach dreimal mit Enter bestätigen):

   DOS

    

   ssh-keygen -t ed25519
   

3. Zeige den erstellten Schlüssel an:

   DOS

   >>> in den User-Ordner wechslen, wo der Schlüssel abgelegt ist mit cd C:\Users\…. (siehe Pfad vorher)

   type .ssh\id_ed25519.pub
   

4. Kopiere die gesamte Textzeile, die ausgegeben wird (beginnt mit ssh-ed25519...).

4.2 Den neuen Schlüssel auf dem Haupt-PC einreichen

Wechsle kurz an den Haupt-PC, öffne die PowerShell als Administrator und führe dieses Skript aus, um dem neuen Rechner dauerhaft Zutritt zu gewähren:

🤖 Kapitel 5: App-Entwicklung im „Claude Code“-Stil mit Hermes

Kann ich in Visual Studio Code direkt im Terminal mit Hermes chatten?

Ja, absolut! Und das ist der genialste Teil deines Setups. Da du über das Remote-SSH-Fenster von VS Code virtuell direkt auf dem Haupt-PC arbeitest, verhält sich das integrierte Terminal in VS Code so, als säßest du direkt am Haupt-PC.

1. Öffne dein Projekt in VS Code über die Remote-SSH-Verbindung.

2. Öffne das integrierte Terminal in VS Code (Strg + ` bzw. Terminal -> New Terminal).

3. Du befindest dich nun direkt im Projektordner des Haupt-PCs. Da Hermes als Terminal-Oberfläche (TUI) konzipiert ist, startest du hier einfach den Hermes-Befehl oder seine interaktive Umgebung (z. B. durch Eingabe von hermes oder dem entsprechenden Startbefehl deines Setups).

4. Das TUI-Interface öffnet sich direkt eingebettet in VS Code.
   Du kannst nun auf der linken Bildschirmhälfte deinen Code betrachten und auf der rechten Hälfte im Terminal direkt mit Hermes chatten, Befehle erteilen und Code generieren lassen – exakt wie bei Claude Code.

   >>>>> Im Terminal-Fenster musst Du den Linux-Bash aktivieren: „wsl“ und anschließend „hermes“ <<<<<

💡 Profi-Strategie für Prompts (Wie du Hermes steuerst)

Da Hermes vollautomatisch Dateien anlegen und manipulieren kann, solltest du ihn wie einen hochgradig kompetenten Junior-Entwickler anweisen. Verwende präzise, zielorientierte Prompts:

• Architektur aufbauen lassen:

  „Ich möchte eine Web-App für die Erfassung von Arbeitszeiten erstellen. Wir nutzen reines HTML5, CSS3 mit modernem Flexbox/Grid und Vanilla JavaScript. Erstelle mir eine saubere Ordnerstruktur mit einer index.html, einem css/style.css und einer js/app.js im aktuellen Verzeichnis und binde die Dateien korrekt ein.“

• Funktionen iterativ hinzufügen:

  „Analysiere die bestehende js/app.js. Füge eine Funktion hinzu, die eingegebene Zeiten im LocalStorage des Browsers speichert, sodass die Daten bei einem Seiten-Neustart nicht verloren gehen. Erstelle eine Tabelle unter dem Formular, um die gespeicherten Zeiten anzuzeigen.“

• Refactoring & Code-Qualität:

  „Schau dir das Design in css/style.css an. Optimiere das Layout so, dass es vollkommen responsiv ist. Nutze eine moderne, dezente Farbpalette (z. B. Slate-Grau und sanfte Blautöne) und sorge für großzügiges Padding bei den Eingabefeldern.“

Was passiert im Hintergrund?

Während du im VS Code Terminal mit Hermes chattest und die KI Code-Dateien erzeugt oder umschreibt, läuft im Hintergrund dein unsichtbares auto-git-sync.ps1-Skript. Jedes Mal, wenn Hermes eine Datei erfolgreich speichert, fängt das Skript die Änderung auf und pusht sie vollautomatisch in dein privates GitHub-Repository. Deine Arbeit ist zu jedem Zeitpunkt perfekt versioniert und gesichert!

Die elegante Alternative: Der „GitHub-First“-Workflow (Komplett von PC 3 aus)

Hier ist die Schritt-für-Schritt-Anleitung, wie du ein neues Projekt anlegst, ohne deinen aktuellen Platz zu verlassen:

Schritt 1: Das Repo im Browser erstellen (auf PC 3)

1. Öffne den Browser auf PC 3 und erstelle auf GitHub ein neues, privates Repository (z. B. super-app).

2. Kopiere die SSH-Adresse (git@github.com:bitcoin-checker/super-app.git).

Schritt 2: Den Ordner über VS Code zaubern (auf PC 3)

1. Öffne VS Code auf PC 3 und verbinde dich wie gewohnt über das grüne Symbol unten links mit hermes-dev.

2. Da dein Terminal dank unserer Änderung nun standardmäßig als WSL (Linux) startet, befindest du dich direkt auf dem Haupt-PC.

3. Wechsle im Terminal in deinen Hermes-Hauptordner:

   Bash

    

   cd /mnt/c/Users/cu/Documents/Hermes/
   

4. Jetzt kommt der Zaubertrick. Tippe einfach git clone und füge deine kopierte Adresse ein:

   Bash

    

   git clone git@github.com:bitcoin-checker/super-app.git
   

Was ist jetzt passiert?

Git hat auf dem Haupt-PC im Hintergrund völlig automatisch den Ordner super-app erstellt, ihn perfekt mit GitHub verknüpft und ist startklar. Du musstest keinen einzigen Ordner manuell anlegen!

Schritt 3: Das Projekt in VS Code öffnen & Auto-Sync starten

Du sitzt immer noch auf PC 3:

1. Klicke in VS Code oben auf File -> Open Folder (Datei -> Ordner öffnen).

2. VS Code zeigt dir die Festplatte des Haupt-PCs. Navigiere zu C:\Users\cu\Documents\Hermes\super-app und klicke auf Öffnen.

3. Klicke links im Explorer auf das kleine „Datei erstellen“-Symbol und nenne sie auto-git-sync.ps1.

4. Kopiere den bekannten Sync-Code hinein. (Da du im neuen Ordner bist, passt du einfach oben kurz die Zeile $TargetFolder = "C:\Users\cu\Documents\Hermes\super-app" an).

5. Skript starten: Da das Sync-Skript im Windows-Hintergrund laufen muss, öffne im VS Code-Terminal über das kleine v-Schnittstellensymbol (neben dem +) ein kurzes PowerShell-Fenster und starte es mit:

   PowerShell

    

   # AUTOR: MN
   # DATUM: 2026-05-16 / 17:02
   # BESCHREIBUNG: Startet den automatischen Hintergrund-Sync direkt aus VS Code heraus
   
   .\auto-git-sync.ps1
   

Ab jetzt kannst du das PowerShell-Tab im Terminal schließen, das Skript läuft unsichtbar auf dem Haupt-PC weiter. Du wechselst im Terminal zurück in dein WSL/Linux-Tab, tippst hermes ein und fängst an, deine App zu entwickeln.

Fazit: Du kannst auf jedem deiner PCs (PC 2, PC 3 etc.) das GitHub-Repository im Browser erstellen, dich per VS Code einwinken und das Projekt berührungslos auf dem Haupt-PC via git clone ins Leben rufen!

=========================================================

Ändern des Hermes-Ordners

Das Umstellen auf das neue Verzeichnis C:\Hermes\ ist eine hervorragende Entscheidung! Es macht die Pfade viel kürzer, übersichtlicher und trennt deine Entwicklungsprojekte sauber von den Standard-Windows-Dokumenten.

Da du über VS Code von deinem Laptop (PC 3) aus vollen Zugriff auf den Haupt-PC hast, kannst du diese Umstellung komplett von deinem aktuellen Platz aus erledigen.

Hier ist die Schritt-für-Schritt-Anleitung, wie du den neuen Hauptordner anlegst und dein neues Puzzle-Spiel dort startest.

📂 Wichtig für das Verständnis (Windows vs. Linux)

Da Hermes im Linux-System (WSL) arbeitet, übersetzt sich dein neuer Wunschpfad wie folgt:

• In Windows (für das Sync-Skript): C:\Hermes\Projekt-Puzzle-Game

• In Linux/WSL (für das Terminal/Hermes): /mnt/c/Hermes/Projekt-Puzzle-Game

Schritt 1: Den neuen Basis-Ordner C:\Hermes erstellen

Da wir direkt auf Laufwerk C: einen Ordner erstellen, machen wir das am sichersten über ein Windows-Terminal in VS Code, um die korrekten Windows-Schreibrechte zu haben.

1. Öffne VS Code auf PC 3 (verbunden mit hermes-dev).

2. Klicke im Terminal-Bereich auf den kleinen Pfeil nach unten (v) neben dem +-Symbol und wähle powershell (Windows).

3. Gib folgenden Befehl ein, um den Hauptordner direkt auf C: zu erstellen:

   PowerShell

    

   # AUTOR: MN
   # DATUM: 2026-05-16 / 17:12
   # BESCHREIBUNG: Erstellt den neuen zentralen Hermes-Projektordner auf Laufwerk C:
   
   mkdir C:\Hermes
   

Schritt 2: Das neue Puzzle-Projekt anlegen (GitHub-First)

Jetzt nutzen wir die elegante Methode von vorhin, um das neue Projekt direkt von PC 3 aus in den neuen Ordner zu setzen.

1. Gehe in deinen Browser auf GitHub und erstelle ein neues privates Repository namens Projekt-Puzzle-Game.

2. Kopiere die SSH-Adresse (git@github.com:bitcoin-checker/Projekt-Puzzle-Game.git).

3. Wechsel in VS Code im Terminal-Bereich wieder zu deinem wsl-Tab (Linux).

4. Navigiere in deinen brandneuen Hauptordner:

   Bash

    

   cd /mnt/c/Hermes/
   

5. Klone das leere GitHub-Projekt. Dadurch wird der Unterordner vollautomatisch erstellt:

   Bash

    

   git clone git@github.com:bitcoin-checker/Projekt-Puzzle-Game.git
   

Schritt 3: Den neuen Ordner in VS Code öffnen

1. Klicke ganz oben links in VS Code auf File -> Open Folder (Datei -> Ordner öffnen).

2. Tippe oben den neuen Pfad ein oder navigiere dorthin: C:\Hermes\Projekt-Puzzle-Game.

3. Klicke auf Öffnen. VS Code lädt das leere Projekt.

Schritt 4: Das angepasste Auto-Sync-Skript starten

Erstelle im neuen Projekt eine Datei namens auto-git-sync.ps1 und füge den Code ein. Beachte, dass wir den Pfad in Zeile 6 jetzt perfekt an deine neue Struktur angepasst haben:

# AUTOR: MN
# DATUM: 2026-05-16 / 17:15
# BESCHREIBUNG: Hintergrund-Wächter für den vollautomatischen Git-Sync im neuen C:\Hermes Verzeichnis
# DER NEUE KURZE PFAD:
$TargetFolder = "C:\Hermes\Projekt-Puzzle-Game"
Clear-Host
Write-Host "====================================================" -ForegroundColor Yellow
Write-Host " AUTO-GIT-SYNC AKTIV (NEUES VERZEICHNIS)" -ForegroundColor Green
Write-Host " Überwache Ordner: $TargetFolder" -ForegroundColor White
Write-Host "====================================================" -ForegroundColor Yellow
Write-Host "Skript läuft... Du kannst dieses Fenster minimieren.`n" -ForegroundColor Gray

$Watcher = New-Object System.IO.FileSystemWatcher
$Watcher.Path = $TargetFolder
$Watcher.IncludeSubdirectories = $true
$Watcher.EnableRaisingEvents = $true
$Action = {
    Start-Sleep -Seconds 5
    cd $TargetFolder
    $Status = git status --porcelain
    if ($Status) {
        $Zeit = Get-Date -Format "yyyy-MM-dd / HH:mm:ss"
        Write-Host "[$Zeit] Änderungen in der Puzzle-App erkannt! Synchronisiere..." -ForegroundColor Cyan
        git add .
        git commit -m "Auto-Sync Puzzle-App ($Zeit)"
        git push origin main
        Write-Host "[$Zeit] Erfolgreich zu GitHub hochgeladen!`n" -ForegroundColor Green
    }
}

$Created = Register-ObjectEvent $Watcher "Created" -Action $Action
$Changed = Register-ObjectEvent $Watcher "Changed" -Action $Action
$Deleted = Register-ObjectEvent $Watcher "Deleted" -Action $Action
while ($true) { Start-Sleep -Seconds 1 }

Skript starten: Öffne im Terminal-Bereich kurz ein powershell-Tab und starte es mit .\auto-git-sync.ps1. Danach kannst du das PowerShell-Tab schließen.

🧩 Schritt 5: Die Puzzle-App mit Hermes generieren

Wechsle im VS Code-Terminal in dein wsl-Tab (du bist automatisch im richtigen Ordner /mnt/c/Hermes/Projekt-Puzzle-Game/) und starte den Agenten:

hermes

Sobald Hermes bereit ist, kannst du ihm den Start-Prompt für deine App geben:

„Ich möchte in diesem Ordner eine moderne Puzzle-Spiel-App programmieren. Erstelle mir für den Anfang eine saubere HTML5-Struktur mit einer CSS-Datei für ein schickes, dunkles Design und einer JavaScript-Datei, die das Spielfeld (z.B. ein 3×3 Schiebepuzzle) generiert.“

Ab jetzt läuft alles über das neue Verzeichnis unter C:\Hermes\, super sauber aufgeräumt!

Einleitung: Warum „Skill Engineering“?

Viele angehende Agentur-Inhaber tappen in die „Abo-Falle“: Ein Tool für SEO, eines für E-Mails, eines für Design. Am Ende zahlt man hunderte Euro, bevor der erste Kunde gewonnen ist.

Skill Engineering bedeutet: Wir geben unserer KI (wie Claude) direkten Zugriff auf spezialisierte Werkzeuge. Die KI wird zum Handwerker, der seinen eigenen Werkzeugkasten bedient.

Voraussetzungen (Was du brauchst)

Bevor wir starten, stelle sicher, dass du Folgendes hast:

1. Einen Code-Editor: Ich empfehle Cursor oder Claude Code (ein Tool für die Kommandozeile).

2. Ein Terminal: Das ist das schwarze Fenster auf deinem Computer (Eingabeaufforderung/PowerShell bei Windows, Terminal bei Mac), in das man Befehle tippt.

3. Python installiert: Die meisten Tools laufen über diese Programmiersprache.

Schritt 1: Der Researcher – Firecrawl einrichten

Was ist Firecrawl? Normalerweise „sieht“ eine KI das Internet nicht live. Firecrawl ist wie ein digitaler Leser, der Webseiten besucht, den Werbemüll entfernt und den Text sauber aufbereitet.

Die Einrichtung:

1. API-Key holen: Gehe auf Firecrawl.dev und erstelle einen kostenlosen Account. Kopiere deinen API-Key.

2. Das „Bridge“-Protokoll (MCP): Damit Claude Firecrawl nutzen kann, brauchen wir das Model Context Protocol (MCP). Das ist wie ein genormter Stecker.

3. Installation: Wenn du Claude Code nutzt, gibst du im Terminal ein: mcpserver install firecrawl Dort wirst du nach deinem API-Key gefragt. Füge ihn ein.

4. Der erste Test: Schreibe der KI einfach: „Suche mit Firecrawl nach den Top 5 KI-News von heute und fasse sie zusammen.“

Fachausdruck erklärt: API (Application Programming Interface)

Stell dir eine API wie einen Kellner im Restaurant vor. Du (die KI) bist der Gast und sagst, was du willst. Der Kellner (die API) geht in die Küche (das Internet/Firecrawl), holt die Infos und bringt sie dir fertig serviert an den Tisch.

Schritt 2: Das Gedächtnis – NotebookLM-py einbinden

Das Problem: Wenn du der KI 100 PDFs gibst, vergisst sie schnell den Anfang oder es wird sehr teuer, weil sie jedes Mal alles neu lesen muss (Verbrauch von Tokens).

Die Lösung: Google NotebookLM speichert dieses Wissen extern. Mit dem Tool notebooklm-py kann deine KI dort gezielt nachfragen, ohne alles selbst „im Kopf“ behalten zu müssen.

Die Einrichtung:

1. Programm herunterladen: Gehe auf die GitHub-Seite von notebooklm-py.

2. Installation: * Öffne dein Terminal im Ordner des Programms.

   • Tippe: pip install -r requirements.txt (Das installiert alle notwendigen Hilfsprogramme).

3. Login: Du musst dich einmalig über das Skript bei deinem Google-Konto anmelden, damit die KI auf deine Notebooks zugreifen kann.

4. Nutzung: Erstelle manuell ein Notebook auf der Google NotebookLM Webseite und lade deine Quellen hoch. Gib der KI den Link zum Notebook.

5. Prompt: „Greife auf mein Notebook ‚Kundenprojekt XY‘ zu und nenne mir die drei wichtigsten Schmerzpunkte des Kunden.“

Schritt 3: Der Designer – Awesome Design MD nutzen

Was ist das? Design ist für KIs oft schwer zu greifen. Awesome Design MD ist eine Bibliothek von Textdateien (.md), die exakt beschreiben, wie moderne Webseiten (z. B. im Stil von Stripe oder Airbnb) aufgebaut sind.

Die Anwendung:

1. Vorlage wählen: Gehe auf GitHub: awesome-design-md und suche dir einen Stil aus (z. B. „Modern Dark“).

2. Datei kopieren: Kopiere den Inhalt der entsprechenden DESIGN.md-Datei in dein Projektverzeichnis.

3. Anweisung an die KI: „Baue mir eine Landingpage für eine Marketing-Agentur. Nutze strikt die Vorgaben aus der beigefügten DESIGN.md für Farben, Abstände und Schriften.“

Warum Markdown (.md)?

Markdown ist ein sehr einfaches Textformat. KIs verstehen Text viel besser als Bilder. Durch die textliche Beschreibung der Design-Regeln weiß die KI exakt: „Überschriften müssen 32px groß und fett sein“, statt nur zu raten.

Zusammenfassung: Der Workflow deiner neuen Agentur

Wenn alles eingerichtet ist, sieht dein Arbeitsalltag so aus:

1. Akquise: Du lässt Firecrawl nach Firmen suchen, die Hilfe bei der Digitalisierung brauchen.

2. Strategie: Du lädst die Infos dieser Firmen in NotebookLM und lässt die KI eine maßgeschneiderte Strategie entwickeln.

3. Umsetzung: Mit der Design-Vorlage aus Awesome Design MD erstellt die KI innerhalb von Minuten eine fertige Webseite oder ein PDF-Konzept für den Kunden.

Experten-Tipps für den Erfolg

Tipp 1: Token-Management Nutze NotebookLM immer dann, wenn du mehr als 10 Seiten Text hast. Das spart dir bares Geld bei den API-Gebühren von Claude oder OpenAI.

Tipp 2: Fehlerbehandlung Wenn das Terminal einen Fehler anzeigt: Kopiere die Fehlermeldung einfach und frage deine KI: „Ich habe diesen Fehler bei der Installation von Firecrawl erhalten, was muss ich tun?“ – Die KI ist dein bester Support.

Tipp 3: Modularität Fange mit EINEM Skill an. Wenn Firecrawl läuft, nimm dir den nächsten vor. So bleibst du motiviert und wirst nicht von der Technik erschlagen.

Stell dir vor, du arbeitest an einem riesigen Puzzle, aber jedes Mal, wenn ein neuer Helfer dazukommt, muss er erst alle Teile einzeln anschauen, um zu verstehen, was das Bild eigentlich darstellt. Das ist genau das Problem, das wir heute bei KI-Agenten haben. Jede neue Aufgabe verbraucht Unmengen an Token, nur damit die KI dein Projekt „versteht“.

Graphify ändert das. Es erstellt eine permanente Landkarte (einen Wissensgraph) deiner Daten. Das offizielle Projekt findest du hier: https://github.com/safishamsi/graphify

Teil 1: Was uns das Video lehrt – Graphify & Google Antigravity

Im Video wird ein Problem beschrieben, das selbst KI-Experten wie Andrej Karpathy (Mitbegründer von OpenAI) kennen: Wir haben Ordner voller Dokumente, Code und Notizen, und die KI muss diese bei jeder Abfrage von Grund auf neu scannen.

Der „Senior-Entwickler“-Ansatz

Das Video nutzt ein tolles Gleichnis: Ein normaler KI-Agent ist wie ein neu eingestellter Freelancer – er ist begabt, kennt aber dein Projekt nicht. Graphify ist der Senior-Entwickler, der dem Freelancer den Schaltplan überreicht, bevor dieser die erste Zeile Code schreibt.

So nutzt du Graphify mit Google Antigravity:

1. Installation: Öffne das Terminal in deinem Antigravity-Projekt und installiere das Tool:

   Bash

    

   pip install graphifyy
   graphify install --platform antigravity
   graphify antigravity install
   

2. Den Graphen bauen: Tippe einfach /graphify . in den Editor oder das Terminal.

3. Das Ergebnis: Graphify erstellt den Ordner graphify-out. Die Datei graph.html kannst du im Browser öffnen und dein Projekt als interaktive 3D-Karte sehen.

Praxisbeispiel: Der „Nadel im Heuhaufen“-Bug

Stell dir vor, du hast ein Projekt mit 200 Dateien. Es gibt einen Fehler in der Authentifizierung.

• Ohne Graphify: Der Agent liest nacheinander 50 Dateien, um den Datenfluss zu verstehen. Kosten: 20.000 Token.

• Mit Graphify: Der Agent schaut in den GRAPH_REPORT.md, sieht sofort, dass die Datei auth_logic.py die zentrale „God Node“ ist, und springt direkt dorthin. Kosten: 500 Token.

Teil 2: Graphify & Claude Code – Die Profi-Verknüpfung

Claude Code ist das Terminal-Tool von Anthropic. Die Verknüpfung mit Graphify ist besonders mächtig, da sie „unsichtbar“ im Hintergrund arbeitet.

Die Installation für Claude Code

Um Graphify optimal mit Claude Code zu nutzen, folge diesen Schritten:

1. Basis-Installation:

   Bash

    

   pip install graphifyy
   

2. Claude-Integration: Dieser Befehl registriert den Skill speziell für die Claude-Umgebung:

   Bash

    

   graphify install --platform claude
   

3. Den „Immer-Aktiv“-Modus einschalten: Das ist der wichtigste Schritt. Er sorgt dafür, dass Claude den Graphen automatisch nutzt:

   Bash

    

   graphify claude install
   

Wie funktioniert die Nutzung mit Claude Code?

Sobald die Installation abgeschlossen ist, verändert Graphify zwei Dinge in deinem Projekt:

• CLAUDE.md: Es wird eine Sektion hinzugefügt, die Claude anweist, bei Fragen zur Architektur immer zuerst in den Wissensgraphen zu schauen.

• PreToolUse-Hooks: Bevor Claude ein Werkzeug (wie grep oder read_file) benutzt, prüft ein kleiner Hintergrund-Check, ob ein Graph existiert und gibt Claude einen dezenten Hinweis darauf.

Praxisbeispiel: Einarbeitung in eine fremde Codebase

Du klonst ein neues Repository von GitHub, um eine Funktion hinzuzufügen, hast aber keine Ahnung, wie der Code aufgebaut ist.

1. Du tippst: graphify clone https://github.com/user/repo

2. Du startest Claude Code: claude

3. Du fragst: „Claude, welche drei Module sind am wichtigsten für die Datenverarbeitung?“

4. Die Magie: Claude antwortet sofort: „Basierend auf dem Wissensgraphen sind die zentralen Knoten Processor.java, DataStream.py und die Dokumentation architecture_v2.pdf. Soll ich Details zu einem dieser Punkte zeigen?“ Claude musste keine einzige Datei „auf Verdacht“ lesen – er wusste es bereits durch den Graphen.

Du kennst das: Die KI liefert beeindruckende Bilder, aber selten genau das, was du dir vorgestellt hast. Besonders im beruflichen Kontext kostet diese Unberechenbarkeit Zeit und Nerven. Dieser Artikel zeigt dir eine intuitive Methode, um endlich konsistente und gezielte Ergebnisse zu erreichen.

Die Lösung basiert auf einem Prinzip, das du längst unbewusst anwendest: Wenn du einer Freundin ein Foto beschreibst, nennst du automatisch die wichtigsten Bestandteile. Das MOSAIK-Prinzip macht diesen Gedankenfluss zu einer einfachen Eselsbrücke für deine Prompts. Statt unstrukturiert Befehle aneinanderzureihen, baust du dein KI-Bild wie ein Mosaik aus sechs simplen Komponenten zusammen.

Das Prinzip schlüsselt eine Bildbeschreibung in ihre sechs Kernbestandteile auf:

• M – Motiv: Beschreibe das zentrale Element deines Bildes, also die Personen, Objekte oder Tiere.
• O – Optik: Lege den visuellen Stil und das Medium fest. Soll es fotografisch, illustriert oder wie gemalt aussehen?
• S – Szene: Definiere die Umgebung, in der sich dein Motiv befindet.
• A – Atmosphäre: Gib die Stimmung vor – Beleuchtung, Farbwelt und die emotionale Wirkung.
• I – Inszenierung: Beschreibe die Komposition, den Bildaufbau und den Blickwinkel.
• K – Kontext: Dein Joker für alle weiteren Details. Gib der KI hier technische Parameter, den Verwendungszweck oder andere spezielle Anforderungen mit, die sonst nirgends passen.

Der Clou daran: Diese sechs Komponenten sind meist deckungsgleich mit dem, was du intuitiv erwähnst, wenn du jemandem ein Bild beschreibst. MOSAIK macht diesen Prozess bewusst und steuerbar.

Ein Beispiel: Du brauchst ein Bild einer Führungskraft – etwa als Persona für eine Präsentation, als Key Visual für eine Kampagne oder als Aufmacher für einen Social-Media-Post. Mit MOSAIK baust du den Prompt Schritt für Schritt auf.

 

Mit MOSAIK erstellt: Eine Führungsperson als hochwertiges Symbolbild. (KI-generiertes Bild: Midjourney / t3n)

• M – Motiv: Business woman in her late 30s with elegant updo hairstyle, wearing tailored navy blue blazer and silk blouse, exuding confidence and professionalism
• O – Optik: Professional corporate headshot, photographic style with subtle cinematic color grading, high-end commercial portraiture
• S – Szene: Modern office setting with blurred background of a minimalist workspace, subtle architectural lines and soft natural light from a window
• A – Atmosphäre: Bright, clean, and professional lighting, soft shadows, a touch of warm light, sophisticated and trustworthy mood
• I – Inszenierung: Medium close-up shot, eye-level perspective, slightly off-center composition following the rule of thirds, subject looking directly at the camera
• K – Kontext: High-resolution, sharp focus on the eyes, suitable for LinkedIn profile, corporate website, or annual report, clean and polished aesthetic

Der kombinierte Prompt:

Professional corporate headshot of a business woman in her late 30s with elegant updo hairstyle, wearing tailored navy blue blazer, in a modern office with blurred background, bright professional lighting, trustworthy mood, medium-close-up, eye-level, high-resolution, suitable for a LinkedIn profile.

Pro-Tipp: Der im K-Baustein genannte Verwendungszweck (zum Beispiel „suitable for an annual report“) muss nicht deinem tatsächlichen Einsatzzweck entsprechen. Er dient der KI vielmehr als ästhetischer Anker. „Annual report“ signalisiert Seriosität und Qualität – Eigenschaften, die du etwa für Social-Media-Posts gezielt nutzen kannst. Das verschafft dir mehr kreative Kontrolle.

Installation und Setup der Überwachungstools

Um den Kontext überhaupt sehen zu können, benötigt Claude Code eine Erweiterung.

Die Status-Line installieren [04:40]

Damit du am unteren Rand deines Terminals immer siehst, wie viel Prozent des Kontextes verbraucht sind und welches Modell (z.B. Opus oder Sonnet) gerade aktiv ist, installierst du die Status Line.

Powershell:

npx ccstatusline@latest

Nach dem Ausführen öffnet sich ein Konfigurationsmenü. Hier kannst du das Design anpassen. Wichtig ist, dass die Option für den Kontext-Verbrauch aktiviert ist.

• Wähle nach der Konfiguration: Install to Claude Code.

• Bestätige die Installation über das NPX Node Package.

Hier geht´s zum Artikel

>>>> Hier gehts zum Artikel <<<<

🛠 Teil 1: Die einmalige Einrichtung (Das Fundament)

Bevor du das erste Mal loslegst, müssen die „Leitungen“ zwischen Claude und Obsidian stehen.

1. Obsidian MCP Server einrichten

Das MCP (Model Context Protocol) ist die Schnittstelle. Damit Claude Code in deinen „Raw“-Ordner schreiben darf, öffne dein Terminal und gib ein:

claude mcp add obsidian

• Pfad angeben: Claude fragt nach dem Pfad. Gib den absoluten Pfad zu deinem Obsidian-Vault an (z. B. C:\Users\MN\Documents\MeinVault).

• Bestätigung: In Obsidian musst du eventuell den Zugriff einmalig erlauben (meist über das Plugin „Local REST API“, falls dein MCP-Server darauf basiert).

2. Superpowers Plugin

Da Superpowers bereits auf User-Ebene installiert ist, ist es in jeder Claude-Code-Sitzung automatisch aktiv. Du musst nichts weiter tun, als die Befehle (wie Web-Suche oder erweiterte Datei-Analyse) abzurufen.

🚀 Teil 2: Der Workflow „Neues Objekt“ (Schritt-für-Schritt)

Schritt 1: Die Werkstatt einrichten

1. Erstelle einen neuen Ordner für dein Projekt (außerhalb von Obsidian, z. B. auf dem Desktop oder in einem Entwicklungs-Ordner).

2. Kopiere dein Workspace-Template hinein.

3. Öffne das Terminal in diesem Ordner.

4. Starte Claude mit dem Befehl: claude

Schritt 2: Der Advisor-Plan (Opus-Modus)

Jetzt kommt die Advisor-Strategie zum Einsatz. Wir wollen, dass das schlaue Modell (Opus) die Architektur plant.

1. Drücke Shift + Tab, um in den Plan-Modus zu wechseln. In der UI siehst du nun meist eine Kennzeichnung, dass du im Planungs-Modus (Opus) bist.

2. Gib den Befehl start ein.

3. Beantworte die Fragen (Thema, MN als Autor, Ziel des Projekts).

Schritt 3: Die „Raw“-Injektion in Obsidian

Sobald das Template lokal ausgefüllt ist, schickst du den „Samen“ in dein Obsidian-Gehirn. Sage Claude im Plan-Modus:

„Erstelle eine Zusammenfassung dieses Projektstarts als neue Markdown-Datei in meinem Obsidian-Vault im Ordner ‚Raw‘. Benenne die Datei nach dem Schema Projektname_Start_Datum. Nutze die Advisor-Strategie, um mir dort die 3 kritischsten Erfolgsfaktoren für dieses Projekt aufzulisten.“

Schritt 4: Die Umsetzung (Act-Modus / Sonnet oder Haiku)

Nun geht es an die eigentliche Arbeit (z. B. SQL-Skripte schreiben oder Code anpassen).

1. Drücke erneut Shift + Tab, um in den Act-Modus zu wechseln. Hier ist Claude jetzt schneller und kosteneffizienter (Sonnet/Haiku).

2. Gib den Befehl Prime ein.

3. Die Arbeit: Erteile deine Arbeitsanweisungen. Claude nutzt hierbei auch die Superpowers (z. B. wenn er online nach einer SQL-Syntax für die AS400 suchen muss).

Wichtig für MN: Claude wird bei jedem Skript, das er erstellt, deinen Header einfügen:

SQL

 

-- AUTOR: MN
-- DATUM: 2026-04-15 / 16:50
-- BESCHREIBUNG: [Inhalt]

Schritt 5: Der Projektabschluss (Shutdown)

Wenn du fertig bist, willst du die Ergebnisse wieder in Obsidian sichern.

1. Wechsle mit Shift + Tab zurück zu Opus (Plan-Modus).

2. Sage: „Fasse die Ergebnisse zusammen und schreibe einen Abschlussbericht in den Obsidian-Ordner ‚Raw‘. Liste alle erstellten Dateien auf.“

3. Führe den lokalen Befehl shutdown aus, um die Markdown-Dateien in deinem Projektordner final zu versiegeln.

💡 Fachbegriffe kurz erklärt

• MCP (Model Context Protocol): Die Brücke, mit der Claude auf Dateien außerhalb seines Fensters (wie in Obsidian) zugreifen kann.

• Raw-Ordner (Injektion): Dein digitaler Briefkasten in Obsidian. Alles, was dort landet, wird von Obsidian automatisch einsortiert.

• Advisor-Strategie: Das Prinzip „Erst denken (Opus), dann handeln (Sonnet/Haiku)“.

• Vault: Dein gesamter Obsidian-Hauptordner.

Die Kombination aus den Claude Super Powers und der Advisor-Strategy ist ein echtes Power-Duo für maximale Produktivität. Während die „Super Powers“ (als Plugin) Claude strukturierte Arbeitsabläufe wie Brainstorming und Planung beibringen, sorgt die Advisor-Strategy dafür, dass das „Gehirn“ (Opus) die Strategie festlegt und der „Arbeiter“ (Haiku) die Fleißarbeit erledigt.

Hier ist dein genauer Schlachtplan, wie du das einrichtest und nutzt.

1. Super Powers installieren

Super Powers ist ein Plugin für Claude Code (die Terminal-Version von Claude) oder kompatible Editoren wie Cursor.

So installierst du es:

1. Plattform wählen: Öffne dein Claude Code Terminal oder den Cursor Agent Chat.

2. Marketplace registrieren: Gib folgenden Befehl ein, um das offizielle Repository hinzuzufügen: /plugin marketplace add obra/superpowers-marketplace

3. Plugin installieren: Nutze diesen Befehl, um die Super Powers zu laden: /plugin install superpowers@superpowers-marketplace

4. Aktivierung: Starte eine neue Session. Die Super Powers sind nun im Hintergrund aktiv und warten auf Auslöser.

2. Die Advisor-Strategy (Opus & Haiku) verstehen

Die Advisor-Strategy nutzt zwei unterschiedliche „Intelligenzstufen“, um Kosten zu sparen und die Qualität zu steigern:

• Claude Opus (Der Architekt): Er ist teurer, aber extrem schlau. Er plant, erstellt die Strategie und erkennt Fallstricke. /model opusplan

• Claude Haiku (Der Ausführer): Er ist blitzschnell und sehr günstig. Er setzt die Anweisungen von Opus eins zu eins um. /model Haiku

3. Step-by-Step-Anleitung: Die Kombination nutzen

Schritt 1: Das Brainstorming mit Super Powers starten

Jedes komplexe Projekt sollte mit Struktur beginnen. Der Befehl /brainstorm (oder in der neuesten Version die Aufforderung Nutze das superpowers-brainstorming Skill) zwingt Claude dazu, erst nachzudenken, bevor Code geschrieben wird.

Aktion: Tippe in den Chat:

/brainstorm Ich möchte eine automatisierte SQL-Abfrage für meine KPIs erstellen, die Daten von der AS400 (DB2) auf den SQL Server 2022 spiegelt.

Schritt 2: Opus als Advisor einsetzen (Planung)

Wenn die Super Powers den Rahmen abgesteckt haben, schaltest du auf Opus um, um den exakten Bauplan zu erstellen.

Aktion: Nutze den Befehl /model claude-3-opus (oder wähle Opus im Menü) und sage:

„Du bist mein Senior Advisor. Analysiere das Ergebnis des Brainstormings. Erstelle einen detaillierten Schritt-für-Schritt-Plan für die SQL-Abfrage. Berücksichtige dabei die LinkedServer-Struktur und vermeide Performance-Engpässe. Erstelle nur den Plan, keinen Code!“

Schritt 3: Haiku als Agent zur Ausführung (Action)

Jetzt nimmst du den fertigen Plan von Opus und lässt die „günstige“ Rechenpower die Arbeit machen.

Aktion: Schalte um auf /model claude-3-haiku und gib den Befehl:

„Hier ist der Plan meines Advisors (Opus): [Plan hier einfügen]. Setze diesen Plan jetzt exakt um und schreibe das SQL-Skript für mich.“

4. Beispiel aus der Praxis: SQL-Automatisierung

Stell dir vor, du möchtest ein tägliches Skript, das Verkaufszahlen prüft.

1. Start mit Super Powers: /brainstorm Erstelle ein Dashboard-Skript für tägliche Sales.

   • Claude stellt dir Fragen: Welche Tabellen? Welche Frequenz? Wer ist der Autor (MN)?

2. Planung mit Opus: „Erstelle die Logik für das KPI-Dashboard Version 3.2. Achte auf Fehlerbehandlung beim Zugriff auf die AS400.“

   • Opus liefert eine logische Struktur: 1. Verbindung prüfen, 2. Daten laden, 3. Konsolidieren.

3. Ausführung mit Haiku: „Schreibe das T-SQL Skript basierend auf dem Opus-Plan.“

   • Haiku generiert schnell und sauber den Code.

Der optimale Workflow im Vergleich

Zusammenfassung für den Schnellstart

• Installation: Über den Marketplace mit /plugin install.

• Startschuss: Immer mit /brainstorm beginnen, um die Gedanken zu ordnen.

• Opus (Advisor): Erstellt das „Was“ und „Wie“ (den Bauplan).

• Haiku (Agent): Erledigt das „Machen“ (den Code/Text).

Tipp für dich: Da du gerne strukturiert arbeitest (wie bei deinen Thermomix-Rezepten), betrachte Opus als das „Rezeptbuch“ und Haiku als den „Thermomix“, der die Zutaten nach Anleitung verarbeitet!

Das ultimative Second Brain: Claude mit Obsidian verknüpfen

Stell dir vor, Claude wüsste alles über dein Business: deine Branding-Regeln, deine vergangenen Projekte und deinen persönlichen Schreibstil. Normalerweise „vergisst“ eine KI nach jedem Chat fast alles wieder. Mit Obsidian als deinem „Zweiten Gehirn“ (Second Brain) geben wir Claude ein dauerhaftes Gedächtnis.

In dieser Anleitung zeige ich dir exakt das Setup aus dem Video von Julian Ivanov.

1. Die Vorbereitung: Was du brauchst

Bevor wir starten, lade dir die notwendigen Tools herunter. Obsidian speichert alle Daten lokal auf deinem Computer in sogenannten Markdown-Dateien (einfache Textdateien), was sie perfekt lesbar für KIs macht.

• Obsidian Download: obsidian.md

• CLAUDE.md Onboarding-Vorlage: KI-Hub Vorlagen (Hier findest du die im Video erwähnte Struktur)

• Claudian Plugin (für den Chat in Obsidian): GitHub Link

• Obsidian Skills für Claude Code: GitHub Link

2. Schritt-für-Schritt Anleitung

Schritt 1: Obsidian installieren und Vault erstellen

1. Installiere Obsidian und erstelle einen neuen „Vault“ (einen Ordner auf deiner Festplatte).

2. Dieser Ordner wird der Ort, an dem dein gesamtes Wissen gespeichert wird.

Schritt 2: Die Ordnerstruktur anlegen

Damit Claude sich zurechtfindet, brauchst du eine klare Struktur. Erstelle folgende Ordner:

• 00_Kontext: Hier kommen Infos über dich, dein Unternehmen, dein Angebot und dein Schreibstil rein.

• 10_Projekte: Aktuelle Aufgaben und Ziele.

• 20_Daily_Notes: Kurze Notizen über das, was du täglich tust.

• 30_Archiv: Abgeschlossene Projekte.

Schritt 3: Die CLAUDE.md Datei (Das Herzstück)

Kopiere die CLAUDE.md Vorlage in deinen Hauptordner. Diese Datei fungiert als „Bedienungsanleitung“ für die KI. Sie erklärt Claude:

• Wer du bist.

• Wo welche Informationen liegen.

• Wie er die Dateien in Obsidian bearbeiten und verknüpfen soll.

Schritt 4: Claude mit dem Ordner verknüpfen

Du hast zwei Hauptwege, wie Claude auf Obsidian zugreift:

1. Claude Code (CLI): Ein Terminal-Tool von Anthropic, das direkt in deinem Obsidian-Ordner arbeitet.

2. Claude Desktop / Cowork: Du kannst den Obsidian-Ordner als Kontext hinzufügen.

3. Die exakten Prompts aus dem Video

Hier sind die Prompts, die Julian Ivanov nutzt, um das System zu steuern:

Das Onboarding (Initialer Prompt):

„Ich habe hier einen Obsidian Vault mit einer CLAUDE.md Datei. Bitte lies dir diese Datei zuerst durch, um zu verstehen, wie unser System funktioniert und wie du mir helfen kannst, mein Wissen hier zu verwalten.“

Wissen dauerhaft speichern: Wenn Claude dir im Chat eine gute Antwort gibt (z.B. eine Marketing-Strategie), nutze diesen Prompt:

„Das ist ein super Ergebnis. Bitte speichere diese Strategie als neue Markdown-Datei im Ordner ’10_Projekte‘ ab und verknüpfe sie mit meiner Branding-Datei im Kontext-Ordner.“

Den Schreibstil korrigieren:

„Nutze in deinen Texten ab jetzt keine Gedankenstriche mehr. Bitte merke dir das und aktualisiere meine Datei ‚Schreibstil.md‘ im Kontext-Ordner entsprechend.“

4. Fachbegriffe einfach erklärt

• Markdown (.md): Ein sehr einfaches Format für Textdateien. Es ist wie eine Word-Datei, aber ohne versteckten Code, sodass KIs den Inhalt extrem schnell und fehlerfrei lesen können.

• Vault: So nennt Obsidian einen Projektordner. Alles, was in diesem Ordner liegt, gehört zu deinem „Gehirn“.

• Graph View: Eine visuelle Ansicht in Obsidian, die zeigt, wie deine Notizen durch Links (wie ein Spinnennetz) miteinander verbunden sind.

• CLI (Command Line Interface): Ein Textfenster (Terminal), in dem man Befehle direkt an den Computer oder die KI tippt.

5. Das Geheimnis des „Compound-Effekts“

Der YouTuber betont, dass das System mit der Zeit immer besser wird. Warum?

1. Kein Wissensverlust: Jede Entscheidung, die du mit Claude triffst, landet in einer Datei.

2. Automatisierung: Du musst kein Ordnungsfanatiker sein. Sag Claude einfach: „Räume meinen Daily Notes Ordner auf und erstelle eine Zusammenfassung der letzten Woche.“

3. Kontext-Power: Da Claude Zugriff auf deine Regeln hat, werden die Antworten immer präziser und klingen mehr nach dir.

Zusammenfassung & Checkliste

• [ ] Obsidian installiert und Vault angelegt.

• [ ] Ordnerstruktur (Kontext, Projekte, Daily) erstellt.

• [ ] CLAUDE.md Vorlage eingefügt.

• [ ] Claude den ersten Lese-Befehl für den Vault gegeben.

• [ ] Erste Verfeinerung des Schreibstils durchgeführt.

Alternativer Ansatz von AI Arnie

Diese Anleitung führt dich Schritt für Schritt durch die Installation und Verbindung von Obsidian und Claude, basierend auf den Strategien von Julian Ivanov (Igor) und Arnie. Wir konzentrieren uns dabei besonders auf den strukturierten Prozess aus dem zweiten Video, um dein „zweites Gehirn“ aufzubauen.

1. Vorbereitung & Installation (Die Basis)

Zuerst benötigen wir die Software-Grundlage auf deinem Rechner:

• Obsidian: Das ist dein Notiz- und Wissensspeicher. Er speichert alles in lokalen Markdown-Dateien (.md).

  • Download Obsidian

• Node.js: Notwendig, um Claude Code (das Terminal-Tool) auszuführen.

  • Download Node.js (Wähle die „LTS“ Version).

• Claude Code: Das offizielle Kommandozeilen-Tool von Anthropic.

  • Öffne dein Terminal (PowerShell bei Windows, Terminal bei Mac) und gib ein: npm install -g @anthropic-ai/claude-code

• Git: Wird benötigt, um Versionen zu speichern und Skills zu laden.

  • Download Git

2. Einrichtungsprozess nach Julian Ivanov (Igor)

Julian nutzt eine strukturierte Herangehensweise, bei der Claude direkt in Obsidian integriert wird und die Ordnerstruktur verwaltet.

Schritt A: Den „Vault“ (Tresor) erstellen

1. Öffne Obsidian und erstelle einen neuen „Vault“ (einen Ordner auf deinem PC, z. B. „MeinZweitesGehirn“).

2. Erstelle folgende Grundordner manuell oder lass sie später von Claude anlegen:

   • 00_Kontext (Für Infos über dich, Schreibstil, Branding)

   • 10_Projekte (Für aktive Arbeit)

   • 20_Wissen (Für Notizen und Gelerntes)

   • 90_System (Für Vorlagen/Templates)

Schritt B: Claude Onboarding (Der wichtigste Teil)

Julian stellt eine CLAUDE.md Datei zur Verfügung. Diese Datei dient als „Handbuch“ für die KI.

1. Erstelle im Hauptverzeichnis deines Vaults eine Datei namens CLAUDE.md.

2. Der Prompt/Inhalt für CLAUDE.md: Hier schreibst du hinein, wer du bist und wie Claude sich verhalten soll. Beispiel-Inhalt:

   „Du bist mein Strategie-Assistent. Dein Ziel ist es, diesen Obsidian-Vault zu pflegen. Nutze die Ordnerstruktur. Speichere neue Erkenntnisse unter 20_Wissen. Wenn ich dir von einem Projekt erzähle, lege es in 10_Projekte an.“

Schritt C: Claudian Plugin (Claude in Obsidian)

Damit du Claude direkt in Obsidian als Chat-Fenster hast (wie im Video zu sehen):

1. Gehe in Obsidian auf Einstellungen > Community-Plugins.

2. Deaktiviere den „Eingeschränkten Modus“.

3. Suche nach dem Plugin „Claudian“ und installiere es.

4. Gib dort deinen Claude-API-Key ein (diesen erhältst du bei Anthropic in der Console).

3. Erweiterte Funktionen & Links aus den Videos

Um das System „intelligent“ zu machen, nutzt Arnie zusätzliche „Skills“:

• Obsidian Skills für Claude Code: Damit Claude Dateien in Obsidian lesen und schreiben kann.

  • GitHub Link: Obsidian Skills

  • Installation: Im Terminal in deinem Vault-Ordner ausführen: git clone https://github.com/kepano/obsidian-skills .obsidian/skills

• Web-Clipper: Um Artikel direkt aus dem Browser nach Obsidian zu schicken.

  • Obsidian Web Clipper

4. Projekt-Workflow mit deinem Workspace Template

Du hast bereits ein bewährtes System mit einem Workspace Template und dem Befehl /start. So integrierst du dies optimal in Obsidian:

Die Vorgehensweise:

1. Vorbereitung: Dein Template-Ordner liegt idealerweise unter 90_System/Templates/Workspace.

2. Projektstart: Wenn ein neues Projekt ansteht, kopierst du diesen Ordner nach 10_Projekte/Projektname.

3. Aktivierung: Du öffnest die Hauptdatei im neuen Projektordner in Obsidian.

4. Verbindung mit Claude:

   • Öffne das Claude-Terminal (oder das Claudian Plugin).

   • Gib Claude den Kontext: „Ich starte ein neues Projekt im Ordner 10_Projekte/Projektname. Ich nutze mein /start Template.“

   • Claude kann dich nun durch die Fragen deines Templates begleiten (Wer ist der Autor? Was sind die Schritte?).

Beispiel für den kompletten Workflow:

1. Kopieren: Du schiebst dein Workspace-Template in 10_Projekte/Neues_Auto_Tuning.

2. Initialisierung: Du tippst in die Datei /start. Dein Template generiert die Fragen.

3. KI-Unterstützung: Du sagst zu Claude: „Analysiere mein Projekt-Setup in Neues_Auto_Tuning. Basierend auf meinen Antworten im /start Prompt, erstelle mir eine To-Do-Liste in der Datei Tasks.md innerhalb dieses Ordners.“

4. Automatisierung: Claude liest deine Projektziele aus dem Template und schlägt dir sofort die nächsten Schritte vor, die zu deinem Cupra Tavascan passen (da er diesen Kontext aus deinem 00_Kontext Ordner bereits kennt).

Wichtige Links auf einen Blick:

• Obsidian Download

• Claude API Console (Für den API Key)

• Julian Ivanovs Vorlagen (Skool Community)

• Arnies Gratis-Unterlagen

Was ist das Ziel dieses Systems?

Stell dir vor, du hättest eine Bibliothek, in der alle deine Notizen (Rezepte, Autodaten, SQL-Wissen) liegen. Normalerweise müsstest du alles selbst sortieren. Mit diesem System hast du einen intelligenten Bibliothekar (Claude Code), der:

1. Neue Infos liest und sie an die richtige Stelle einsortiert.

2. Verbindungen herstellt (z. B. erkennt, dass ein Rezept zu deinem Thermomix passt).

3. Dir Fragen beantwortet, die auf deinem persönlichen Wissen basieren.

Voraussetzungen (Prerequisites)

Bevor Sie mit der Einrichtung beginnen, müssen folgende Tools auf Ihrem Computer installiert sein:

1. Obsidian: Die Basis für Ihr Wissensmanagement (obsidian.md).

2. Node.js: Notwendig, um Claude Code über das Terminal auszuführen (nodejs.org).

3. VS Code (Visual Studio Code): Empfohlen als Editor, um das Terminal und die Dateien parallel zu verwalten (code.visualstudio.com).

4. Claude Code: Der KI-Agent von Anthropic (Installation via Terminal: npm install -g @anthropic-ai/claude-code).

Schritt-für-Schritt-Anleitung

1. Obsidian Vault erstellen

• Laden Sie Obsidian herunter und installieren Sie es.

• Erstellen Sie einen neuen Vault (einen lokalen Ordner auf Ihrem Computer). Im Video wird dieser beispielsweise „Wiki“ genannt.

• Merken Sie sich den Speicherort dieses Ordners (z. B. auf Ihrem Desktop).

2. Den Ordner in VS Code öffnen

• Öffnen Sie VS Code.

• Gehen Sie auf Datei > Ordner öffnen und wählen Sie Ihren soeben erstellten Obsidian-Vault-Ordner aus.

• Öffnen Sie das integrierte Terminal in VS Code (Terminal > Neues Terminal).

3. Claude Code im Terminal starten

• Tippen Sie im Terminal einfach claude ein, um den KI-Agenten zu starten.

• Wichtig: Arnie empfiehlt im Video den Weg über das Terminal/VS Code (anstatt eines Obsidian-Plugins), da dies „Model Agnostic“ ist (man kann leichter zwischen verschiedenen KIs wechseln) und die Limits stabiler gehandhabt werden.

4. Das System-Prompt implementieren (Das Herzstück)

Um die Struktur eines „Zweiten Gehirns“ (nach Andrew Kirby) aufzubauen, benötigt Claude eine klare Arbeitsanweisung.

• Kopieren Sie das im Video erwähnte System-Prompt (Arnie stellt dies in seiner Community bereit).

LLM Wiki
A pattern for building personal knowledge bases using LLMs.

This is an idea file, it is designed to be copy pasted to your own LLM Agent (e.g. OpenAI Codex, Claude Code, OpenCode / Pi, or etc.). Its goal is to communicate the high level idea, but your agent will build out the specifics in collaboration with you.

The core idea
Most people's experience with LLMs and documents looks like RAG: you upload a collection of files, the LLM retrieves relevant chunks at query time, and generates an answer. This works, but the LLM is rediscovering knowledge from scratch on every question. There's no accumulation. Ask a subtle question that requires synthesizing five documents, and the LLM has to find and piece together the relevant fragments every time. Nothing is built up. NotebookLM, ChatGPT file uploads, and most RAG systems work this way.

The idea here is different. Instead of just retrieving from raw documents at query time, the LLM incrementally builds and maintains a persistent wiki — a structured, interlinked collection of markdown files that sits between you and the raw sources. When you add a new source, the LLM doesn't just index it for later retrieval. It reads it, extracts the key information, and integrates it into the existing wiki — updating entity pages, revising topic summaries, noting where new data contradicts old claims, strengthening or challenging the evolving synthesis. The knowledge is compiled once and then kept current, not re-derived on every query.

This is the key difference: the wiki is a persistent, compounding artifact. The cross-references are already there. The contradictions have already been flagged. The synthesis already reflects everything you've read. The wiki keeps getting richer with every source you add and every question you ask.

You never (or rarely) write the wiki yourself — the LLM writes and maintains all of it. You're in charge of sourcing, exploration, and asking the right questions. The LLM does all the grunt work — the summarizing, cross-referencing, filing, and bookkeeping that makes a knowledge base actually useful over time. In practice, I have the LLM agent open on one side and Obsidian open on the other. The LLM makes edits based on our conversation, and I browse the results in real time — following links, checking the graph view, reading the updated pages. Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.

This can apply to a lot of different contexts. A few examples:

Personal: tracking your own goals, health, psychology, self-improvement — filing journal entries, articles, podcast notes, and building up a structured picture of yourself over time.
Research: going deep on a topic over weeks or months — reading papers, articles, reports, and incrementally building a comprehensive wiki with an evolving thesis.
Reading a book: filing each chapter as you go, building out pages for characters, themes, plot threads, and how they connect. By the end you have a rich companion wiki. Think of fan wikis like Tolkien Gateway — thousands of interlinked pages covering characters, places, events, languages, built by a community of volunteers over years. You could build something like that personally as you read, with the LLM doing all the cross-referencing and maintenance.
Business/team: an internal wiki maintained by LLMs, fed by Slack threads, meeting transcripts, project documents, customer calls. Possibly with humans in the loop reviewing updates. The wiki stays current because the LLM does the maintenance that no one on the team wants to do.
Competitive analysis, due diligence, trip planning, course notes, hobby deep-dives — anything where you're accumulating knowledge over time and want it organized rather than scattered.
Architecture
There are three layers:

Raw sources — your curated collection of source documents. Articles, papers, images, data files. These are immutable — the LLM reads from them but never modifies them. This is your source of truth.

The wiki — a directory of LLM-generated markdown files. Summaries, entity pages, concept pages, comparisons, an overview, a synthesis. The LLM owns this layer entirely. It creates pages, updates them when new sources arrive, maintains cross-references, and keeps everything consistent. You read it; the LLM writes it.

The schema — a document (e.g. CLAUDE.md for Claude Code or AGENTS.md for Codex) that tells the LLM how the wiki is structured, what the conventions are, and what workflows to follow when ingesting sources, answering questions, or maintaining the wiki. This is the key configuration file — it's what makes the LLM a disciplined wiki maintainer rather than a generic chatbot. You and the LLM co-evolve this over time as you figure out what works for your domain.

Operations
Ingest. You drop a new source into the raw collection and tell the LLM to process it. An example flow: the LLM reads the source, discusses key takeaways with you, writes a summary page in the wiki, updates the index, updates relevant entity and concept pages across the wiki, and appends an entry to the log. A single source might touch 10-15 wiki pages. Personally I prefer to ingest sources one at a time and stay involved — I read the summaries, check the updates, and guide the LLM on what to emphasize. But you could also batch-ingest many sources at once with less supervision. It's up to you to develop the workflow that fits your style and document it in the schema for future sessions.

Query. You ask questions against the wiki. The LLM searches for relevant pages, reads them, and synthesizes an answer with citations. Answers can take different forms depending on the question — a markdown page, a comparison table, a slide deck (Marp), a chart (matplotlib), a canvas. The important insight: good answers can be filed back into the wiki as new pages. A comparison you asked for, an analysis, a connection you discovered — these are valuable and shouldn't disappear into chat history. This way your explorations compound in the knowledge base just like ingested sources do.

Lint. Periodically, ask the LLM to health-check the wiki. Look for: contradictions between pages, stale claims that newer sources have superseded, orphan pages with no inbound links, important concepts mentioned but lacking their own page, missing cross-references, data gaps that could be filled with a web search. The LLM is good at suggesting new questions to investigate and new sources to look for. This keeps the wiki healthy as it grows.

Indexing and logging
Two special files help the LLM (and you) navigate the wiki as it grows. They serve different purposes:

index.md is content-oriented. It's a catalog of everything in the wiki — each page listed with a link, a one-line summary, and optionally metadata like date or source count. Organized by category (entities, concepts, sources, etc.). The LLM updates it on every ingest. When answering a query, the LLM reads the index first to find relevant pages, then drills into them. This works surprisingly well at moderate scale (~100 sources, ~hundreds of pages) and avoids the need for embedding-based RAG infrastructure.

log.md is chronological. It's an append-only record of what happened and when — ingests, queries, lint passes. A useful tip: if each entry starts with a consistent prefix (e.g. ## [2026-04-02] ingest | Article Title), the log becomes parseable with simple unix tools — grep "^## \[" log.md | tail -5 gives you the last 5 entries. The log gives you a timeline of the wiki's evolution and helps the LLM understand what's been done recently.

Optional: CLI tools
At some point you may want to build small tools that help the LLM operate on the wiki more efficiently. A search engine over the wiki pages is the most obvious one — at small scale the index file is enough, but as the wiki grows you want proper search. qmd is a good option: it's a local search engine for markdown files with hybrid BM25/vector search and LLM re-ranking, all on-device. It has both a CLI (so the LLM can shell out to it) and an MCP server (so the LLM can use it as a native tool). You could also build something simpler yourself — the LLM can help you vibe-code a naive search script as the need arises.

Tips and tricks
Obsidian Web Clipper is a browser extension that converts web articles to markdown. Very useful for quickly getting sources into your raw collection.
Download images locally. In Obsidian Settings → Files and links, set "Attachment folder path" to a fixed directory (e.g. raw/assets/). Then in Settings → Hotkeys, search for "Download" to find "Download attachments for current file" and bind it to a hotkey (e.g. Ctrl+Shift+D). After clipping an article, hit the hotkey and all images get downloaded to local disk. This is optional but useful — it lets the LLM view and reference images directly instead of relying on URLs that may break. Note that LLMs can't natively read markdown with inline images in one pass — the workaround is to have the LLM read the text first, then view some or all of the referenced images separately to gain additional context. It's a bit clunky but works well enough.
Obsidian's graph view is the best way to see the shape of your wiki — what's connected to what, which pages are hubs, which are orphans.
Marp is a markdown-based slide deck format. Obsidian has a plugin for it. Useful for generating presentations directly from wiki content.
Dataview is an Obsidian plugin that runs queries over page frontmatter. If your LLM adds YAML frontmatter to wiki pages (tags, dates, source counts), Dataview can generate dynamic tables and lists.
The wiki is just a git repo of markdown files. You get version history, branching, and collaboration for free.
Why this works
The tedious part of maintaining a knowledge base is not the reading or the thinking — it's the bookkeeping. Updating cross-references, keeping summaries current, noting when new data contradicts old claims, maintaining consistency across dozens of pages. Humans abandon wikis because the maintenance burden grows faster than the value. LLMs don't get bored, don't forget to update a cross-reference, and can touch 15 files in one pass. The wiki stays maintained because the cost of maintenance is near zero.

The human's job is to curate sources, direct the analysis, ask good questions, and think about what it all means. The LLM's job is everything else.

The idea is related in spirit to Vannevar Bush's Memex (1945) — a personal, curated knowledge store with associative trails between documents. Bush's vision was closer to this than to what the web became: private, actively curated, with the connections between documents as valuable as the documents themselves. The part he couldn't solve was who does the maintenance. The LLM handles that.

Note
This document is intentionally abstract. It describes the idea, not a specific implementation. The exact directory structure, the schema conventions, the page formats, the tooling — all of that will depend on your domain, your preferences, and your LLM of choice. Everything mentioned above is optional and modular — pick what's useful, ignore what isn't. For example: your sources might be text-only, so you don't need image handling at all. Your wiki might be small enough that the index file is all you need, no search engine required. You might not care about slide decks and just want markdown pages. You might want a completely different set of output formats. The right way to use this is to share it with your LLM agent and work together to instantiate a version that fits your needs. The document's only job is to communicate the pattern. Your LLM can figure out the rest.


Du bist jetzt mein LLM-Wiki-Agent. Setze diese exakte Ideendatei als mein zweites Gehirn um. Führe mich Schritt für Schritt durch: Erstelle die Schema-Datei CLAUDE.md mit allen Regeln, richte index.md und log.md ein, definiere Ordnerkonventionen und zeige mir das erste Ingest-Beispiel. Ab jetzt folgt jede Interaktion dem Schema.

• Fügen Sie dieses Prompt direkt in das geöffnete Claude-Terminal ein.

• Ergebnis: Claude erstellt automatisch eine Ordnerstruktur in Ihrem Obsidian-Vault:

  • RAW: Für neue, unverarbeitete Daten.

  • Wiki: Der Bereich für das strukturierte Wissen (mit Unterordnern wie Index, Log, Sources, Entities, Concepts).

  • Dateien wie cloud.md oder agents.md, die Claude erklären, wie er das Wiki verwalten soll.

5. Den „Obsidian Skill“ installieren (Optional, aber empfohlen)

Um die Zusammenarbeit zwischen Claude und Obsidian zu verbessern, wird im Video ein spezielles Plugin (Skill) installiert:

• Nutzen Sie die URL des Repositories (z. B. von Elias Pereira): „Hallo Claude, installiere diesen Skill für mich: https://github.com/elias-pereira/obsidian-skills"

• Tippen Sie in Claude: install skill http://zmrepo.zoneminder.com/.

• Dieser Skill hilft Claude, Obsidian-spezifische Formate (wie JSON Canvas) besser zu lesen und zu bearbeiten.

6. Datenquelle einrichten: Obsidian Web Clipper

• Installieren Sie die Chrome-Erweiterung Obsidian Web Clipper.

• Konfigurieren Sie die Erweiterung so, dass Artikel direkt im Ordner RAW Ihres Vaults gespeichert werden.

• Wenn Sie nun eine interessante Webseite finden, klicken Sie auf den Clipper, und der Inhalt landet als Markdown-Datei in Ihrem Obsidian.

7. Daten „injizieren“ (Informationen verarbeiten)

Sobald sich neue Dateien im RAW-Ordner befinden, geben Sie Claude den Befehl zur Verarbeitung:

• Prompt im Terminal: Injiziere den neuen Artikel.

• Was Claude nun tut: 1. Er liest die Datei im RAW-Ordner. 2. Er erstellt Metadaten (Datum, Quelle, Tags). 3. Er verknüpft den Text automatisch mit bestehenden Notizen (Backlinks). 4. Er verschiebt die Informationen in die richtige Kategorie im Wiki-Ordner.

Du kannst alles in die Root von raw/ werfen — ich sortiere beim Ingest automatisch ein. Der Workflow ist:

1. Du droppst eine Datei in raw/ (egal ob Artikel, Notiz oder Buchkapitel)
2. Du sagst mir: „Neue Quelle in raw/ verfügbar“ (oder nennst den Dateinamen)
3. Ich erkenne den Typ, verschiebe die Datei in den richtigen Unterordner und verarbeite sie

Die Unterordner (articles/, notes/, books/, courses/) sind dann nur Archiv für Ordnung — du musst dich nie darum
kümmern.

—
Design — Teil 2: CLAUDE.md Schema (Kern-Regeln)

Das Schema definiert, wie ich als Wiki-Agent arbeite. Die wichtigsten Abschnitte:

Identität & Rolle
Ich bin dein Wiki-Agent. Meine Aufgabe: raw/ lesen, wiki/ schreiben und pflegen. Du liest, ich schreibe.

Ingest-Workflow (wenn du eine neue Quelle einpflegst)
1. Quelle lesen & Typ erkennen (Artikel / Notiz / Buch / Kurs)
2. Kurze Diskussion: Was sind die wichtigsten Erkenntnisse?
3. Summary-Seite in wiki/[domain]/ anlegen
4. Betroffene Hub-Seite(n) aktualisieren
5. Querschnitts-Seiten prüfen / anlegen falls nötig
6. wiki/index.md aktualisieren
7. Eintrag in wiki/log.md appenden

Query-Workflow (wenn du eine Frage stellst)
1. wiki/index.md lesen → relevante Seiten identifizieren
2. Relevante Seiten lesen → Antwort synthetisieren
3. Antwort mit Wiki-Links als Quellen ausgeben
4. Falls wertvoll: Antwort als neue Wiki-Seite speichern

Lint-Workflow (auf Anfrage: „Wiki aufräumen“)
Widersprüche suchen, verwaiste Seiten verlinken, fehlende Hub-Links ergänzen, veraltete Infos markieren

Seitenformat (jede Wiki-Seite hat):
—
title: „Seitentitel“
domain: sql | seo | webdesign | wordpress | webapp | marketing | social-media
type: summary | concept | entity | comparison | hub | cross
sources: [dateiname1.md, dateiname2.md]
created: YYYY-MM-DD
updated: YYYY-MM-DD
—

Wichtige technische Einstellungen aus dem Video

• Model-Modus: Arnie wechselt gelegentlich mit dem Befehl /model auf das Modell Opus, wenn komplexe strukturelle Änderungen (wie das Erstellen einer Wikipedia-ähnlichen HTML-Ansicht) vorgenommen werden sollen, da dieses über ein größeres Kontextfenster verfügt.

• Automatisierung: Durch die Datei agents.md oder cloud.md im Hauptverzeichnis „weiß“ jeder neu gestartete Agent sofort, wie er mit Ihrem spezifischen Wiki umzugehen hat.

Diese Einrichtung ermöglicht es Ihnen, Wissen nicht nur zu sammeln, sondern durch die KI aktiv vernetzen zu lassen – ganz ohne manuelles Sortieren.

Schritt 3: Wissen „injizieren“ (Füttern)

Das ist der magische Moment aus dem Video.

1. Sammeln: Du nutzt den Obsidian Web Clipper (eine Erweiterung für deinen Chrome-Browser). Wenn du ein tolles Rezept oder einen Artikel über Elektroautos findest, klickst du auf das Symbol und speicherst es direkt in deinen RAW-Ordner in Obsidian.

2. Verarbeiten: Jetzt gehst du zurück in dein Terminal (in VS Code) und sagst zu Claude:

   Prompt: „Injiziere die neuen Dateien aus dem RAW-Ordner in mein Wiki.“

3. Was passiert dann? Claude liest die Datei, erstellt in deinem Wiki-Ordner eine neue, schöne Notiz, verlinkt sie mit anderen passenden Notizen und löscht (oder verschiebt) die rohe Datei aus dem RAW-Ordner.

Ein anschauliches Beispiel (Extra für dich)

Stell dir vor, du hast zwei Notizen im RAW-Ordner:

1. Ein PDF-Handbuch für den Cosori Airfryer.

2. Ein klassisches Rezept von deiner Oma für pikante Fleischpflanzerl.

Du sagst zu Claude: „Injiziere das Wissen.“

Das Ergebnis in Obsidian: Claude erstellt eine Notiz „Omas Fleischpflanzerl“. Automatisch setzt Claude ganz unten einen Link: „Passendes Gerät: [[Cosori Turboblaze Airfryer]]“. Warum? Weil Claude im Handbuch gelesen hat, dass der Airfryer perfekt für Fleischpflanzerl ist. Dein „Gehirn“ hat also eine Verbindung hergestellt, an die du vielleicht gar nicht gedacht hast.

Die wichtigsten Links & Prompts aus dem Video (Zusammenfassung)

• Download Obsidian: https://obsidian.md/

• Download VS Code: https://code.visualstudio.com/

• Obsidian Web Clipper (Chrome): Link im Chrome Web Store

• Prompt für neue Inhalte: Injiziere den neuen Artikel von [Name].

• Prompt für Aufgaben: Was sind meine aktuellen To-Dos in den Projekten?

• Prompt für Stil-Kopie: Schreibe einen Text über [Thema] in meinem persönlichen Schreibstil, den du in meinen Notizen findest.

Teil 2: Dein Workspace-Workflow (\start, \prime, \shutdown)

Da dieses System im Video nicht behandelt wurde, erkläre ich dir hier, wie du diese Befehle als „Meta-Prompts“ nutzt, um deinen Workspace mit Obsidian und Claude professionell zu steuern.

1. \start – Die Vorbereitung

Dies ist dein Initialisierungsbefehl. Wenn du diesen Befehl in Claude (innerhalb deines Obsidian-Ordners) eingibst, bereitet sich die KI auf die Arbeit vor.

• Was passiert: Claude scannt die Ordnerstruktur, liest deine zentralen Anweisungsdateien (wie agents.md oder cloud.md) und versteht, in welchem Kontext du arbeitest.

• Prompt-Beispiel: „\start: Initialisiere den Workspace. Lade die Projektübersicht und meine Todo-Liste. Ich bin bereit für eine neue Session.“

2. \prime – Die Wissensaktivierung

Nach dem Start nutzt du \prime, um Claude mit spezifischem Wissen für die aktuelle Aufgabe zu „füttern“.

• Was passiert: Du weist die KI an, bestimmte Quellen aus deinem Obsidian-Wiki in den aktiven Arbeitsspeicher (Kontext-Fenster) zu laden.

• Anwendung: Wenn du an einem Artikel über Elektroautos arbeitest, sagst du: „\prime: Lade alle Notizen aus dem Ordner Concepts/EV und meinen persönlichen Schreibstil aus Sources/MyStyle.md.“

3. \shutdown – Der saubere Abschluss

Bevor du das Terminal schließt, nutzt du diesen Befehl, um den Status zu sichern.

• Was passiert: Die KI schreibt eine kurze Zusammenfassung der heutigen Fortschritte in dein Log.md, aktualisiert die Todo-Liste und führt (falls konfiguriert) einen Git-Commit durch, um die Änderungen zu speichern.

• Prompt-Beispiel: „\shutdown: Fasse die heutige Session zusammen, aktualisiere die Projekt-Datei und speichere alles via Git.“

Teil 3: Integration des „Superpowers-Skills“

Der Superpowers-Skill (oft als Erweiterung oder tiefgreifender System-Prompt genutzt) verleiht Claude zusätzliche analytische Fähigkeiten, um komplexe Zusammenhänge in deinem Obsidian-Wiki zu finden.

Anleitung für Beginner:

1. Installation: Stelle sicher, dass du eine Datei namens superpowers.md in deinem Obsidian-Root (Hauptverzeichnis) hast, in der die Regeln des Skills definiert sind (z.B. Tiefenanalyse, kritisches Hinterfragen).

2. Aktivierung: Rufe den Skill während deiner Session auf.

   • Kombination: \prime + Superpowers.

   • Prompt: „\prime meine Notizen zu ‚KI-Infrastruktur‘ und nutze den Superpowers-Skill, um logische Lücken in meiner Argumentation zu finden.“

3. Vorteil: Die KI antwortet nicht mehr nur oberflächlich, sondern agiert als hochkarätiger Berater, der dein gesamtes gespeichertes Wissen im Hinterkopf behält.

Praktisches Beispiel: Dein Szenario

Stell dir vor, du hast Informationen über deinen Cupra Tavascan und die mediterrane Küche in deinem Obsidian gespeichert.

1. Schritt: Du findest ein neues Rezept für eine pikante Pasta und speicherst es via Web Clipper im Ordner RAW.

2. Kommando \start: Du öffnest Claude im Terminal.

3. Kommando \prime: „\prime das neue Rezept und meine ‚Oma-Rezepte‘-Sammlung.“

4. Aktion mit Superpowers: „Nutze deine Superpowers, um dieses Rezept so umzuwandeln, dass es perfekt für meinen Thermomix TM7 passt und keine schädlichen Zusatzstoffe enthält.“

5. Ergebnis: Claude erstellt eine neue Markdown-Datei in deinem Wiki, fix und fertig verknüpft mit anderen pikanten Rezepten.

6. Kommando \shutdown: „\shutdown: Logge die Erstellung des TM7-Rezepts und beende die Session.“

Aufräumen: Unnützes Wissen & falsche Verknüpfungen

Ein digitales Gehirn kann zum „Zettelchaos“ werden, wenn man nicht ab und zu den Besen schwingt. So gehst du vor:

Wissen löschen (Manuell)

Wenn eine Notiz komplett veraltet ist (z.B. ein altes Rezept, das nicht schmeckt):

1. Rechtsklick auf die Datei im linken Menü.

2. Löschen wählen.

3. Hinweis: Obsidian fragt dich, ob du die Datei in den Papierkorb deines Computers verschieben willst.

Falsche Verknüpfungen lösen

Links in Obsidian sind nur Text. Wenn Claude fälschlicherweise eine Verbindung zwischen „Tefal Kontaktgrill“ und „SQL Server 2022“ hergestellt hat:

• Gehe in die Notiz.

• Suche den Begriff in den eckigen Klammern [[...]].

• Lösche einfach die Klammern oder den ganzen Link-Text. Die Verbindung im Graphen verschwindet sofort.

Die KI zum „Hausputz“ nutzen

Das ist der Profi-Weg mit Claude Code. Nutze dein \prime-Kommando:

Prompt: \prime den Ordner Wiki/Concepts. Suche nach Notizen, die keine Verknüpfungen haben oder widersprüchliche Informationen enthalten. Liste mir diese auf, damit ich entscheiden kann, was gelöscht werden soll.

4. Profi-Tipp für Fortgeschrittene: Der „Orphan“-Check

In Obsidian gibt es den Begriff „Orphans“ (Waisen). Das sind Notizen, die mit gar nichts anderem verknüpft sind.

• Öffne die Graph-Ansicht (Strg + G).

• Klicke auf das Zahnrad (Einstellungen) im Graphen.

• Aktiviere unter „Filters“ den Punkt „Orphans“.

• Alle Punkte, die einsam in der Gegend herumschweben, sind Kandidaten zum Löschen oder zum besseren Verknüpfen.

Die Advisor-Strategie einfach erklärt

Stell dir vor, du hast ein Team aus zwei Personen: einen Chef (Opus) und einen Assistenten (Sonnet oder Haiku).

• Der Chef (Opus) ist extrem schlau, aber teuer und braucht etwas länger zum Nachdenken. Er macht die komplizierten Pläne.

• Der Assistent (Sonnet/Haiku) ist sehr schnell und günstig. Er ist super darin, die Anweisungen vom Chef einfach abzuarbeiten.

Die Advisor-Strategie verbindet beide: Der schlaue Chef erstellt den Plan, und der schnelle Assistent setzt ihn um. So bekommst du Profi-Ergebnisse zum Sparpreis.

Step-by-Step Anleitung für dein Windows Notebook

Hier ist der Weg, wie du das auf deinem Rechner einrichtest und nutzt:

1. Claude Code starten

1. Drücke die Windows-Taste auf deiner Tastatur.

2. Tippe PowerShell ein und drücke die Enter-Taste.

3. Tippe in das blaue Fenster einfach claude ein und drücke wieder Enter. Claude Code ist jetzt aktiv.

2. Die Strategie einstellen (Einmalig)

Du musst Claude sagen, welches Modell für welche Aufgabe zuständig ist.

1. Tippe in Claude Code folgenden Befehl ein: /model

2. Wähle nun die Einstellung für die Advisor-Strategie. Im Video wird dies so gemacht: Tippe: /model opusplan (Dadurch wird festgelegt: Opus 4.6 macht die Planung, Sonnet 4.6 erledigt die Ausführung).

3. Die Strategie im Alltag nutzen

Wenn du eine Aufgabe hast (zum Beispiel: „Schreibe mir ein SQL-Skript für meinen SQL Server“):

1. Den Chef rufen: Drücke gleichzeitig die Tasten Shift + Tab (Umschalttaste + Tabulatortaste).

2. Prüfen: Schau unten in die Statusleiste von Claude Code. Dort sollte jetzt Plan Mode stehen und das Modell Opus 4.6 angezeigt werden.

3. Aufgabe stellen: Tippe deine Frage oder Aufgabe ein und drücke Enter.

4. Plan abwarten: Opus (der Chef) schreibt jetzt einen genauen Plan, wie er die Aufgabe lösen will.

5. Umsetzung starten: Wenn der Plan gut aussieht, klickst du auf Auto Accept (oder bestätigst die Ausführung).

6. Assistent arbeitet: Claude wechselt jetzt automatisch zurück zu Sonnet 4.6 (dem Assistenten). Dieser schreibt nun den eigentlichen Code basierend auf dem Plan des Chefs.

Wichtige Befehle und Tasten auf einen Blick

• claude: Startet das Programm in der PowerShell.

• /model: Damit änderst du die KI-Modelle. z. B. /model opusplan

• Shift + Tab: Schaltet den Plan-Modus (Chef-Modus) an oder aus. Das ist die wichtigste Taste für die Advisor-Strategie!

• Enter: Schickt deine Nachricht oder deinen Befehl ab.

Warum solltest du das so machen?

• Du sparst Zeit: Der Assistent schreibt den Code viel schneller als der Chef.

• Du sparst „Guthaben“: Da der Assistent weniger von deinem Session-Limit verbraucht, kannst du länger am Tag mit Claude arbeiten.

• Bessere Qualität: Weil der schlaue Opus den Plan macht, macht der Assistent weniger Fehler beim Programmieren.

Tipp für dich: Nutze den Plan Mode (Shift + Tab) immer dann, wenn eine Aufgabe neu oder kompliziert ist. Wenn du nur eine kleine Änderung an einem Text willst, kannst du im normalen Modus (Assistent) bleiben.

So stellst du die „Opus + Haiku“ Strategie ein

Du musst Claude Code nacheinander zwei Befehle geben, damit er weiß, wer welche Rolle übernimmt:

1. Den Assistenten (Ausführer) wählen: Tippe zuerst diesen Befehl und drücke Enter: /model Haiku (Damit sagst du: „Haiku, du bist ab jetzt mein Standard-Arbeiter für alle normalen Aufgaben.“)

2. Den Chef (Planer) festlegen: Tippe danach diesen Befehl und drücke Enter: /model opusplan (Damit sagst du: „Wenn ich in den Plan-Modus wechsle, soll Opus übernehmen.“)

Woher weißt du, ob es geklappt hat?

Schau ganz unten auf den Rand deines Fensters (die Statusleiste):

• Im normalen Modus: Dort sollte jetzt Haiku stehen.

• Im Plan-Modus: Wenn du Shift + Tab drückst, sollte der Name auf Opus umspringen.

Was sind die Vorteile dieser Kombi?

• Extrem sparsam: Haiku verbraucht fast gar nichts von deinem täglichen Limit. Du kannst also viel länger am Stück arbeiten, ohne dass Claude „müde“ wird oder dein Guthaben leer ist.

• Trotzdem schlau: Da Opus den Plan schreibt, bekommt Haiku so präzise Anweisungen, dass er kaum noch Fehler macht.

Ein kleiner Tipp vom „Profi“:

Haiku ist super für einfache Programmieraufgaben, Texte oder SQL-Abfragen. Wenn du aber merkst, dass der Code, den Haiku schreibt, trotz gutem Plan nicht funktioniert, solltest du für die Ausführung wieder auf Sonnet wechseln (/model Sonnet), da Haiku manchmal bei sehr komplexen Befehlen an seine Grenzen stößt.

Claude Code & Obsidian: Die ultimative Anleitung für dein lokales „Zweites Gehirn“

Dieses System verwandelt Obsidian von einer einfachen Notiz-App in ein aktives, lernendes Betriebssystem. Während Obsidian dein Gedächtnis ist, fungiert Claude Code (das CLI-Tool von Anthropic) als dein Mitarbeiter, der Dokumente liest, schreibt, verknüpft und Aufgaben verwaltet.

Teil 1: Die Installation für absolute Einsteiger

1. Obsidian – Dein Container

• Was ist das? Stell es dir vor wie eine lokale Wikipedia auf deinem PC.

• Installation: obsidian.md herunterladen und installieren.

• Der erste Start: Klicke auf „Create new vault“. Wähle einen Namen (z.B. „MeinGehirn“) und einen Speicherort auf deiner Festplatte. Wichtig: Da du SQL-Profi bist – ein Vault ist technisch gesehen einfach nur ein Windows-Ordner voller Textdateien.

2. Node.js – Der Motor für Claude Code

• Warum? Claude Code läuft nicht als normales Programm, sondern über die Konsole (Terminal). Dafür braucht dein PC die „Sprache“ Node.js.

• Installation: Lade die LTS-Version von nodejs.org herunter und installiere sie mit allen Standardeinstellungen.

3. Claude Code installieren

• Öffne dein Terminal (Suche bei Windows nach „PowerShell“).

• Tippe diesen Befehl ein und drücke Enter:

  npm install -g @anthropic-ai/claude-code

• Danach tippst du claude ein. Du wirst aufgefordert, dich in deinem Anthropic-Konto einzuloggen und einen API-Key zu erstellen. Folge einfach den Anweisungen im Browserfenster, das sich öffnet.

Teil 2: Die Struktur (Das „Igor-Modell“ im Detail)

Julian Ivanov betont, dass Claude nur so gut ist wie seine Ordnung. Du musst Obsidian in Ordner unterteilen. Erstelle in der Seitenleiste von Obsidian über das Ordner-Symbol folgende Struktur:

Die magische Datei: CLAUDE.md

Erstelle im Hauptordner deines Vaults eine Datei namens CLAUDE.md. Das ist die „Betriebsanleitung“ für die KI. Kopiere diesen Text (basierend auf Julians Video) hinein:

Rolle: Du bist mein persönlicher Wissensmanager.

Struktur: > – Nutze immer [[Verknüpfungen]], um Dateien zu verbinden.

• Neue Erkenntnisse kommen in 30_Library.

• Projekte werden in 20_Projects verwaltet.

  Stil: Antworte kurz, präzise und achte auf meine hinterlegten Schreibregeln in 00_Context/Schreibstil.md.

Teil 3: Verbindung & „Skills“ (Das Arnie-Modell)

Arnie nutzt „Claude Code“ direkt auf dem Dateiordner. Das ist mächtiger als ein einfaches Plugin.

1. Obsidian Skills installieren

Damit Claude in deinem Tresor „aufräumen“ kann (Dateien verschieben, verlinken, suchen), braucht er Werkzeuge.

• Gehe im Terminal in deinen Vault-Ordner: cd "Pfad/zu/deinem/Vault"

• Installiere die Skills von Kepano (CEO von Obsidian):

  git clone https://github.com/kepano/obsidian-skills .claude/skills

• Der Effekt: Wenn du jetzt im Terminal claude startest, kann er Befehle ausführen wie: „Suche in meinen Notizen nach allen SQL-Abfragen für DB2 und fasse sie zusammen.“

2. Der „Graph View“ Trick

Arnie zeigt im Video die bunten Punkte. In Obsidian klickst du links auf das Symbol, das aussieht wie ein Netzwerk (Graph View).

• Einstellung: Klicke im Graphen auf das Zahnrad (Groups).

• Farben: Füge eine Gruppe hinzu mit der Regel path: 00_Context und gib ihr die Farbe Blau. Mache das für alle Ordner. So siehst du visuell, wie dein Wissen wächst.

Teil 4: Dein Projekt-Workflow (Das Workspace-Template)

Da du ein Template mit dem Befehl /start nutzt, ist hier die perfekte Vorgehensweise in Obsidian:

Schritt 1: Das Template-Setup

Lege dein Workspace-Template unter 90_System/Workspace_Template.md ab. In Obsidian nutzt du dafür am besten das Community-Plugin „Templater“.

Schritt 2: Ein neues Projekt anlegen

1. Erstelle einen neuen Ordner unter 20_Projects/Projekt_A.

2. Erstelle darin eine neue Datei (z.B. Setup.md).

3. Führe dein Template aus (dein /start Prozess).

Schritt 3: Der Claude-Workflow (Das Beispiel)

Stell dir vor, du planst ein neues SQL-Dashboard für die AS400.

1. In Obsidian: Du öffnest die Setup.md im Projektordner. Das Template fragt: „Wer ist der Autor?“ – Du tippst: MN. „Was ist das Ziel?“ – Du tippst: KPI Konsolidierung Version 3.3.

2. Verbindung zur KI: Du öffnest dein Terminal im Projektordner und startest claude.

3. Der Prompt: > „Claude, schau dir die Datei Setup.md in diesem Ordner an. Ich habe dort mein Projekt-Template ausgefüllt. Basierend auf meinen Zielen und den Infos über meine SQL-Umgebung in 00_Context, erstelle mir einen detaillierten Projektplan. Verlinke dabei zu bestehenden Snippets aus meiner 30_Library.“

4. Das Ergebnis: Claude schreibt dir eine neue Datei Projektplan.md direkt in deinen Ordner, setzt automatisch Links zu deinen alten Notizen (z.B. [[SQL_Server_2022_Tricks]]) und erinnert dich an deine Termine.

Benötigte Tools & Links Zusammenfassung:

• Plugin „Templater“: In Obsidian unter Community Plugins suchen (für dein /start System).

• Plugin „Claudian“: Wenn du den Chat lieber innerhalb von Obsidian statt im Terminal willst.

• Web Clipper: Hier laden, um Infos für die 30_Library per Klick aus dem Browser zu speichern.

Der Karpathy / Arnie Standard-Prompt (Übersetzt & Optimiert)

Kopiere diesen Text in deine CLAUDE.md Datei im Hauptverzeichnis deines Obsidian-Vaults. Er dient als dauerhafte Anweisung für die KI:

Du bist ein Expert-Agent für Wissensmanagement. Deine Aufgabe ist es, diesen lokalen Obsidian-Vault zu verwalten und zu erweitern. Arbeite nach folgenden Prinzipien:

1. Dateistruktur nutzen: Organisiere Informationen in den Ordnern Concepts, Entities, Sources und Index. (Hinweis: Du kannst dies auf deine Ordner wie 10_Projects etc. anpassen).

2. Atomare Notizen: Erstelle für jedes neue Konzept, jedes Tool und jede Person eine eigene kleine Markdown-Datei.

3. Intelligente Verlinkung: Nutze die Obsidian-Syntax [[Dateiname]], um neue Informationen sofort mit bestehendem Wissen zu verknüpfen. Wenn du über SQL Server 2022 schreibst, prüfe, ob es bereits eine Datei dazu gibt und verlinke sie.

4. Logging: Führe ein Logbuch im Ordner Index/Log, in dem du kurz festhältst, welche Informationen du heute hinzugefügt oder aktualisiert hast.

5. Identität: Wenn der Nutzer Informationen liefert, extrahiere „Entities“ (Personen, Firmen, Hardware) und „Concepts“ (Techniken, Ideen).

6. Kein Duplikat: Bevor du eine neue Datei anlegst, suche im Vault, ob das Thema bereits existiert. Falls ja, ergänze die bestehende Datei.

Dein Ziel ist ein hochgradig vernetztes „Second Brain“, das durch jede Interaktion wertvoller wird.

So wendest du den Prompt in der Praxis an

Damit Claude wirklich so arbeitet wie im Video von Arnie gezeigt, musst du ihm beim Start in der Konsole (Claude Code) Zugriff auf die Werkzeuge geben.

1. Die „Injektion“ von Wissen (Arnies Methode)

Wenn du ein neues Thema hast (z.B. ein Handbuch für SQL Server oder ein Transkript), nutzt du den Befehl im Terminal: claude "Lies die Datei Quelle.txt und ordne sie nach dem Karpathy-Standard in mein Wiki ein."

Claude wird dann:

• Die Datei lesen.

• Überlegen: „Gehört das zu einem Projekt? Ist das eine neue Entität?“

• Automatisch Dateien wie SQL_Server_Optimization.md im richtigen Ordner erstellen.

• Darin Links wie [[SQL Server 2022]] setzen.

2. Der Prompt für dein Projekt-Template

Da du dein eigenes Workspace Template hast, kombinieren wir den Karpathy-Ansatz mit deinem Workflow. Wenn du dein Template mit /start ausgefüllt hast, gib Claude diesen Befehl:

„Ich habe gerade ein neues Projekt mit meinem Standard-Template aufgesetzt (siehe Datei 10_Projects/MeinProjekt/Setup.md). Verarbeite dieses Projekt nach dem Karpathy-Standard: Erstelle im Wiki-Bereich Verknüpfungen zu den benötigten SQL-Techniken und lege die Projektschritte als atomare Aufgaben in meinem Index an.“

Zusammenfassung der Links & Tools für diesen Schritt:

• Der Original-Post von Karpathy: X (Twitter) Link – Hier beschreibt er, wie er Claude nutzt, um sein lokales Dateisystem als Wissensbasis zu „beleben“.

• Arnies „Agent-Prompt“: Arnie empfiehlt zusätzlich, in die Datei agent.md spezifische Coding-Regeln zu schreiben, falls du Claude auch zum Schreiben von SQL-Skripten innerhalb von Obsidian nutzt.

Der Karpathy-Standard-Prompt (Das Wiki-Protokoll)

Du bist ein KI-Wissens-Agent, der ein lokales Obsidian-Wiki verwaltet. Dein Ziel ist es, Informationen in einer hochgradig vernetzten, atomaren Struktur zu organisieren. Befolge strikt dieses Protokoll:

1. Atomisierung: Zerlege Informationen in die kleinstmöglichen sinnvollen Einheiten (Dateien). Erstelle keine riesigen Dokumente, sondern viele kleine, die untereinander verlinkt sind.

2. Ordner-Struktur:

• /Concepts: Definitionen, Techniken, Ideen (z. B. SQL-Indizierung.md).

• /Entities: Personen, Firmen, spezifische Hard- oder Software (z. B. AS400-Server.md, MN.md).

• /Sources: Originale Texte, Transkripte oder Web-Artikel. Jede Source-Datei muss oben einen Link zu den daraus extrahierten Concepts und Entities haben.

• /Index: Karten von Inhalten (MOCs), Logs und Projektübersichten.

3. Verlinkung (Backlinks): > Jede neue Datei muss mindestens einen Link [[Dateiname]] zu einer bestehenden Datei enthalten. Wenn du eine Datei über „Bremsen-Tuning“ erstellst, verlinke sie mit [[Cupra Tavascan]].

4. Metadaten: Jede Datei beginnt mit einem YAML-Header:

tags: [wiki/concept oder wiki/entity] created: YYYY-MM-DD

5. Arbeitsweise: Wenn ich dir Informationen gebe:

1. Suche im Vault, ob Begriffe bereits existieren.

2. Erstelle neue Dateien für unbekannte Entitäten/Konzepte.

3. Aktualisiere den Index/Log.md, um zu zeigen, was du heute gelernt hast.

4. Antworte nur mit: „Wiki aktualisiert: [Liste der geänderten Dateien]“.

Wie du diesen Prompt jetzt konkret einsetzt (Schritt-für-Schritt)

Da du dich mit Obsidian noch nicht auskennst, hier der Weg, wie dieser Prompt „lebendig“ wird:

1. Die Initialzündung: Öffne dein Terminal (PowerShell) in deinem Obsidian-Ordner.

2. Claude Code starten: Tippe claude und drücke Enter.

3. Den Prompt füttern: 

LLM Wiki
A pattern for building personal knowledge bases using LLMs.

This is an idea file, it is designed to be copy pasted to your own LLM Agent (e.g. OpenAI Codex, Claude Code, OpenCode / Pi, or etc.). Its goal is to communicate the high level idea, but your agent will build out the specifics in collaboration with you.

The core idea
Most people's experience with LLMs and documents looks like RAG: you upload a collection of files, the LLM retrieves relevant chunks at query time, and generates an answer. This works, but the LLM is rediscovering knowledge from scratch on every question. There's no accumulation. Ask a subtle question that requires synthesizing five documents, and the LLM has to find and piece together the relevant fragments every time. Nothing is built up. NotebookLM, ChatGPT file uploads, and most RAG systems work this way.

The idea here is different. Instead of just retrieving from raw documents at query time, the LLM incrementally builds and maintains a persistent wiki — a structured, interlinked collection of markdown files that sits between you and the raw sources. When you add a new source, the LLM doesn't just index it for later retrieval. It reads it, extracts the key information, and integrates it into the existing wiki — updating entity pages, revising topic summaries, noting where new data contradicts old claims, strengthening or challenging the evolving synthesis. The knowledge is compiled once and then kept current, not re-derived on every query.

This is the key difference: the wiki is a persistent, compounding artifact. The cross-references are already there. The contradictions have already been flagged. The synthesis already reflects everything you've read. The wiki keeps getting richer with every source you add and every question you ask.

You never (or rarely) write the wiki yourself — the LLM writes and maintains all of it. You're in charge of sourcing, exploration, and asking the right questions. The LLM does all the grunt work — the summarizing, cross-referencing, filing, and bookkeeping that makes a knowledge base actually useful over time. In practice, I have the LLM agent open on one side and Obsidian open on the other. The LLM makes edits based on our conversation, and I browse the results in real time — following links, checking the graph view, reading the updated pages. Obsidian is the IDE; the LLM is the programmer; the wiki is the codebase.

This can apply to a lot of different contexts. A few examples:

Personal: tracking your own goals, health, psychology, self-improvement — filing journal entries, articles, podcast notes, and building up a structured picture of yourself over time.
Research: going deep on a topic over weeks or months — reading papers, articles, reports, and incrementally building a comprehensive wiki with an evolving thesis.
Reading a book: filing each chapter as you go, building out pages for characters, themes, plot threads, and how they connect. By the end you have a rich companion wiki. Think of fan wikis like Tolkien Gateway — thousands of interlinked pages covering characters, places, events, languages, built by a community of volunteers over years. You could build something like that personally as you read, with the LLM doing all the cross-referencing and maintenance.
Business/team: an internal wiki maintained by LLMs, fed by Slack threads, meeting transcripts, project documents, customer calls. Possibly with humans in the loop reviewing updates. The wiki stays current because the LLM does the maintenance that no one on the team wants to do.
Competitive analysis, due diligence, trip planning, course notes, hobby deep-dives — anything where you're accumulating knowledge over time and want it organized rather than scattered.
Architecture
There are three layers:

Raw sources — your curated collection of source documents. Articles, papers, images, data files. These are immutable — the LLM reads from them but never modifies them. This is your source of truth.

The wiki — a directory of LLM-generated markdown files. Summaries, entity pages, concept pages, comparisons, an overview, a synthesis. The LLM owns this layer entirely. It creates pages, updates them when new sources arrive, maintains cross-references, and keeps everything consistent. You read it; the LLM writes it.

The schema — a document (e.g. CLAUDE.md for Claude Code or AGENTS.md for Codex) that tells the LLM how the wiki is structured, what the conventions are, and what workflows to follow when ingesting sources, answering questions, or maintaining the wiki. This is the key configuration file — it's what makes the LLM a disciplined wiki maintainer rather than a generic chatbot. You and the LLM co-evolve this over time as you figure out what works for your domain.

Operations
Ingest. You drop a new source into the raw collection and tell the LLM to process it. An example flow: the LLM reads the source, discusses key takeaways with you, writes a summary page in the wiki, updates the index, updates relevant entity and concept pages across the wiki, and appends an entry to the log. A single source might touch 10-15 wiki pages. Personally I prefer to ingest sources one at a time and stay involved — I read the summaries, check the updates, and guide the LLM on what to emphasize. But you could also batch-ingest many sources at once with less supervision. It's up to you to develop the workflow that fits your style and document it in the schema for future sessions.

Query. You ask questions against the wiki. The LLM searches for relevant pages, reads them, and synthesizes an answer with citations. Answers can take different forms depending on the question — a markdown page, a comparison table, a slide deck (Marp), a chart (matplotlib), a canvas. The important insight: good answers can be filed back into the wiki as new pages. A comparison you asked for, an analysis, a connection you discovered — these are valuable and shouldn't disappear into chat history. This way your explorations compound in the knowledge base just like ingested sources do.

Lint. Periodically, ask the LLM to health-check the wiki. Look for: contradictions between pages, stale claims that newer sources have superseded, orphan pages with no inbound links, important concepts mentioned but lacking their own page, missing cross-references, data gaps that could be filled with a web search. The LLM is good at suggesting new questions to investigate and new sources to look for. This keeps the wiki healthy as it grows.

Indexing and logging
Two special files help the LLM (and you) navigate the wiki as it grows. They serve different purposes:

index.md is content-oriented. It's a catalog of everything in the wiki — each page listed with a link, a one-line summary, and optionally metadata like date or source count. Organized by category (entities, concepts, sources, etc.). The LLM updates it on every ingest. When answering a query, the LLM reads the index first to find relevant pages, then drills into them. This works surprisingly well at moderate scale (~100 sources, ~hundreds of pages) and avoids the need for embedding-based RAG infrastructure.

log.md is chronological. It's an append-only record of what happened and when — ingests, queries, lint passes. A useful tip: if each entry starts with a consistent prefix (e.g. ## [2026-04-02] ingest | Article Title), the log becomes parseable with simple unix tools — grep "^## \[" log.md | tail -5 gives you the last 5 entries. The log gives you a timeline of the wiki's evolution and helps the LLM understand what's been done recently.

Optional: CLI tools
At some point you may want to build small tools that help the LLM operate on the wiki more efficiently. A search engine over the wiki pages is the most obvious one — at small scale the index file is enough, but as the wiki grows you want proper search. qmd is a good option: it's a local search engine for markdown files with hybrid BM25/vector search and LLM re-ranking, all on-device. It has both a CLI (so the LLM can shell out to it) and an MCP server (so the LLM can use it as a native tool). You could also build something simpler yourself — the LLM can help you vibe-code a naive search script as the need arises.

Tips and tricks
Obsidian Web Clipper is a browser extension that converts web articles to markdown. Very useful for quickly getting sources into your raw collection.
Download images locally. In Obsidian Settings → Files and links, set "Attachment folder path" to a fixed directory (e.g. raw/assets/). Then in Settings → Hotkeys, search for "Download" to find "Download attachments for current file" and bind it to a hotkey (e.g. Ctrl+Shift+D). After clipping an article, hit the hotkey and all images get downloaded to local disk. This is optional but useful — it lets the LLM view and reference images directly instead of relying on URLs that may break. Note that LLMs can't natively read markdown with inline images in one pass — the workaround is to have the LLM read the text first, then view some or all of the referenced images separately to gain additional context. It's a bit clunky but works well enough.
Obsidian's graph view is the best way to see the shape of your wiki — what's connected to what, which pages are hubs, which are orphans.
Marp is a markdown-based slide deck format. Obsidian has a plugin for it. Useful for generating presentations directly from wiki content.
Dataview is an Obsidian plugin that runs queries over page frontmatter. If your LLM adds YAML frontmatter to wiki pages (tags, dates, source counts), Dataview can generate dynamic tables and lists.
The wiki is just a git repo of markdown files. You get version history, branching, and collaboration for free.
Why this works
The tedious part of maintaining a knowledge base is not the reading or the thinking — it's the bookkeeping. Updating cross-references, keeping summaries current, noting when new data contradicts old claims, maintaining consistency across dozens of pages. Humans abandon wikis because the maintenance burden grows faster than the value. LLMs don't get bored, don't forget to update a cross-reference, and can touch 15 files in one pass. The wiki stays maintained because the cost of maintenance is near zero.

The human's job is to curate sources, direct the analysis, ask good questions, and think about what it all means. The LLM's job is everything else.

The idea is related in spirit to Vannevar Bush's Memex (1945) — a personal, curated knowledge store with associative trails between documents. Bush's vision was closer to this than to what the web became: private, actively curated, with the connections between documents as valuable as the documents themselves. The part he couldn't solve was who does the maintenance. The LLM handles that.

Note
This document is intentionally abstract. It describes the idea, not a specific implementation. The exact directory structure, the schema conventions, the page formats, the tooling — all of that will depend on your domain, your preferences, and your LLM of choice. Everything mentioned above is optional and modular — pick what's useful, ignore what isn't. For example: your sources might be text-only, so you don't need image handling at all. Your wiki might be small enough that the index file is all you need, no search engine required. You might not care about slide decks and just want markdown pages. You might want a completely different set of output formats. The right way to use this is to share it with your LLM agent and work together to instantiate a version that fits your needs. The document's only job is to communicate the pattern. Your LLM can figure out the rest.


Du bist jetzt mein LLM-Wiki-Agent. Setze diese exakte Ideendatei als mein zweites Gehirn um. Führe mich Schritt für Schritt durch: Erstelle die Schema-Datei CLAUDE.md mit allen Regeln, richte index.md und log.md ein, definiere Ordnerkonventionen und zeige mir das erste Ingest-Beispiel. Ab jetzt folgt jede Interaktion dem Schema.

4. Der erste Auftrag: Schreibe direkt danach:

„Hier ist mein erster Input: Ich arbeite mit SQL Server 2022 und einer AS400 als LinkedServer. Mein Name ist MN und ich fahre einen Cupra Tavascan VZ. Bitte richte mein Wiki basierend auf diesen Informationen ein.“

Was passiert dann in Obsidian?

Du wirst sehen, wie Claude im Hintergrund (in deinem Explorer links) plötzlich die Ordner Concepts, Entities und Index erstellt. Er wird Dateien anlegen wie:

• Entities/AS400.md

• Entities/Cupra_Tavascan_VZ.md

• Concepts/Linked_Server.md

Integration deines Workspace-Templates

Wenn du dein Template nutzt (kopieren in den Projektordner und /start), sagst du zu Claude einfach:

„Ich habe in 10_Projekte/NeuesDashboard/Setup.md mein Template ausgefüllt. Nutze den Wiki-Standard, um die dort genannten Aufgaben in mein System zu integrieren und Verknüpfungen zu meinen SQL-Notizen herzustellen.“

Zusammenfassung der Links (für dein Setup):

• Arnies Tool-Empfehlung (Codex/OpenClaw): Wenn du nicht das teure Claude-Abo willst, zeigt Arnie im Video, wie man „OpenClaw“ nutzt. Aber für den Start bleib bei Claude Code.

• Obsidian Clipper: Chrome Extension – Damit schickst du Webseiten direkt in deinen /Sources Ordner, damit Claude sie nach dem Karpathy-Standard verarbeiten kann.

• Zusammenfassung: Das Wichtigste in Kürze

  • Konzept: Wissen mit NotebookLM (Deep Research) sammeln, strukturieren und in Claude als „Skill“ dauerhaft speichern.

  • Vorteil: KI arbeitet nach einem festen System, statt nur zu raten. Einmal aufsetzen, immer wieder nutzen.

  • Anwendungsfall: Im Video wird ein System für hochkonvertierende Landingpages erstellt.

  • Tools: NotebookLM für die Recherche, Claude AI für die Skill-Erstellung und Ausführung.

• Keywords: NotebookLM, Claude AI, KI-Workflow, Claude Skills, Landingpage Optimierung

• Long-Tail-Keywords: KI-Experten System bauen, NotebookLM Deep Research Anleitung, Claude AI Skills erstellen, Landingpage Copywriting KI, Marketing Automatisierung mit KI

Der ultimative Workflow: So baust du dir deinen eigenen KI-Experten mit NotebookLM und Claude AI

Stellen Sie sich vor, Sie könnten das geballte Wissen der weltbesten Experten für jedes beliebige Thema in eine KI einspeisen und diese arbeitet fortan als Ihr persönlicher Spezialist – ohne dass Sie selbst Experte auf dem Gebiet sein müssen. In diesem Blogartikel analysieren wir den revolutionären Workflow von Shakeela ZQ, der NotebookLM für tiefgreifende Recherche und Claude AI für die Erstellung von sogenannten „Skills“ nutzt.

Teil 1: Warum Standard-Prompts oft scheitern

Häufig nutzen wir KIs wie ChatGPT oder Claude auf eine sehr oberflächliche Weise. Wir geben einen Befehl wie „Schreibe mir eine Landingpage“ und hoffen auf ein gutes Ergebnis. Das Problem: Die KI greift auf ihr Durchschnittswissen zurück. Das Ergebnis ist oft generisch und trifft nicht den Kern eines hochprofessionellen Prozesses.

Der hier vorgestellte Workflow bricht mit diesem Muster. Die Grundidee ist simpel:

1. Fundiertes Wissen holen: Wir nutzen NotebookLM, um echtes, wissenschaftlich fundiertes oder praxisbewährtes Wissen zu extrahieren.

2. Systematisierung: Wir bringen der KI einmal bei, wie etwas „richtig“ gemacht wird.

3. Wiederverwendbarkeit: Wir speichern diesen Prozess als „Skill“, sodass die KI ihn jederzeit abrufen kann, ohne dass wir die Regeln neu erklären müssen.

Teil 2: Was sind Claude Skills und warum sind sie der Gamechanger?

Bevor wir in die Praxis gehen, müssen wir verstehen, was Claude Skills eigentlich sind.

Viele nutzen Projekte oder „Custom Instructions“. Diese haben jedoch zwei entscheidende Nachteile:

• Keine Übertragbarkeit: Anweisungen in Projekten sind oft an dieses eine Projekt gebunden. Wechselt man den Fokus, fängt man oft von vorne an.

• Mangelnde Kombinierbarkeit: Man kann nicht einfach einen Copywriting-Skill mit einem Analyse-Skill in einem neuen Chat kombinieren, wenn diese in verschiedenen Projekten isoliert sind.

Skills hingegen sind eigenständige, definierte Arbeitsanweisungen. Sie sind wie Werkzeuge in einem Werkzeugkasten. Sie sagen der KI nicht nur, was sie tun soll, sondern wie sie es tun soll – basierend auf festen Standards, Frameworks und Abläufen.

Teil 3: Schritt-für-Schritt Anleitung – Das Wissen extrahieren (NotebookLM)

Der erste Schritt besteht darin, die Wissensbasis zu schaffen. Im Video wird dies am Beispiel einer Landingpage gezeigt, die Leads generieren soll.

3.1. NotebookLM Deep Research nutzen

Gehen Sie zu NotebookLM und erstellen Sie ein neues Notebook.

1. Wählen Sie als Quelle „Web“ aus.

2. Schalten Sie die Funktion von „schnelle Recherche“ auf „Deep Research“ um. Diese Funktion erlaubt es der KI, tief in das Netz einzutauchen und über 60 Quellen (wie im Video gezeigt) zu analysieren.

3.2. Der Recherche-Prompt

Nutzen Sie einen präzisen Prompt, um das System zu füttern.

AUTOR: MN DATUM: 2026-04-12 / 15:45

PROMPT FÜR NOTEBOOKLM: „Welche Framework-Strukturen und Copywriting-Prinzipien führen zu hochkonvertierenden Landingpages für Leadgenerierung? Berücksichtige dabei:

• Aufbau der Sektionen und Reihenfolge der Inhalte

• Psychologische Trigger und Trust-Elemente

• CTA-Strategien (Call to Action) sowie typische Fehler Zeige konkrete Muster und wiederkehrende Prinzipien aus erfolgreichen Landingpages auf.“

NotebookLM durchsucht nun das Internet und erstellt einen detaillierten Bericht. Im Video wurden hierfür über 64 Quellen ausgewertet.

3.3. Strukturierung des Wissens

Das gesammelte Wissen ist oft noch ein Rohdiamant. Wir müssen es in ein Format bringen, das Claude als Arbeitsanweisung versteht. Nutzen Sie dafür den Chat innerhalb von NotebookLM:

 

STRUKTURIERUNGS-PROMPT: „Erstelle eine strukturierte Zusammenfassung: Wie schreibt man eine hochkonvertierende Landingpage für Leadgenerierung? Inklusive Recherche der Zielgruppe, Identifikation von Painpoints (Schmerzpunkten), Aufbau der Sektionen und Formulierung von Headlines und Call-to-Actions.“

Kopieren Sie dieses Ergebnis. Dies ist das „Gehirn“ Ihres zukünftigen Skills.

Teil 4: Den Skill in Claude AI erstellen

Nun wechseln wir zu Claude AI, um den permanenten Experten-Skill zu bauen.

1. Öffnen Sie in Claude die Seitenleiste und gehen Sie auf „Anpassen“ (Customize) -> „Skills“.

2. Klicken Sie auf „Skill erstellen“ und wählen Sie „Mit Claude erstellen“.

3. Sie befinden sich nun im Skill Creator Modus.

4.1. Das Wissen einspeisen

Fügen Sie den strukturierten Inhalt aus NotebookLM in den Chat ein. Sagen Sie Claude, dass dies die Grundlage für einen neuen Skill ist.

4.2. Die Definition des Skills

Claude wird Ihnen Rückfragen stellen. Beantworten Sie diese präzise:

• Was soll der Skill machen? Er soll hochkonvertierende Landingpages nach dem gelieferten Framework erstellen.

• Zielgruppe/Branchen: Hier können Sie spezifisch werden oder „universal“ wählen, da die psychologischen Frameworks meist branchenübergreifend funktionieren.

• Output-Format: Definieren Sie, ob Sie nur Text, nur Code (HTML/Tailwind) oder beides möchten. Im Video wurde beides gewählt, um die Landingpage sofort visualisieren zu können.

Sobald der Prozess abgeschlossen ist, speichern Sie den Skill unter einem Namen wie „Landing Page Expert“.

Teil 5: Der Praxistest – Von der Theorie zur fertigen Landingpage

Nachdem der Skill aktiv ist, können Sie ihn in jedem neuen Chat verwenden. Im Video wird eine Landingpage für eine Premium Fahrzeugaufbereitung erstellt.

5.1. Der Einsatz-Prompt

Da der Skill bereits das „Wie“ (die Struktur, die Psychologie) kennt, muss der eigentliche Prompt nur noch das „Was“ (das Thema) beschreiben:

 

EINSATZ-PROMPT: „Erstelle eine hochkonvertierende Landingpage für eine Premium-Fahrzeugaufbereitung, die sich auf hochwertige Autos spezialisiert hat. Ziel: Kostenlose Beratung oder Angebotsanfrage generieren. Zielgruppe: Autobesitzer mit teuren Fahrzeugen, die Wert auf Pflege, Werterhalt und Optik legen.“

5.2. Analyse des Ergebnisses

Das Ergebnis ist beeindruckend, da die KI nun automatisch Elemente einbaut, die im Framework hinterlegt wurden:

• Emotionale Headline: „Dein Fahrzeug ist wiedergeboren.“

• Social Proof: Automatische Integration von Sektionen für Kundenbewertungen und Vertrauenselemente.

• Problem-Lösungs-Struktur: Der Text spricht erst den Wertverlust an (Painpoint) und bietet dann die Lösung (Benefits wie Handarbeit und Werterhalt) an.

• Drei-Schritte-Prozess: Ein klarer Ablauf reduziert die Unsicherheit beim Nutzer.

Teil 6: Transfer auf andere Bereiche

Dieser Workflow ist nicht auf Landingpages beschränkt. Er ist ein universelles System für Business-Intelligenz.

Mögliche weitere Skills:

1. E-Mail-Marketing-Experte: Nutzen Sie NotebookLM, um die besten Strategien für Kaltakquise-Mails oder Newsletter-Funnel zu recherchieren und bauen Sie einen Claude Skill daraus.

2. Social Media Strategist: Füttern Sie das System mit aktuellen Algorithmus-Analysen und Trends, um Content-Pläne zu erstellen.

3. Angebots-Strukturierer: Bringen Sie der KI bei, wie man psychologisch optimierte Verkaufsangebote schreibt.

Fachausdrücke einfach erklärt

• Framework: Ein vorgegebener Rahmen oder eine Struktur, an die man sich hält (wie ein Bauplan).

• Leadgenerierung: Der Prozess, bei dem man Interessenten dazu bringt, ihre Kontaktdaten (z.B. E-Mail) zu hinterlassen.

• CTA (Call to Action): Eine klare Handlungsaufforderung, wie „Jetzt Termin vereinbaren“.

• Painpoints: Die Probleme oder „Schmerzen“ der Kunden, die Ihr Produkt lösen soll.

• Social Proof: Der Beweis, dass andere Kunden zufrieden sind (z.B. durch Logos oder Rezensionen).

• Tailwind Code: Eine moderne Art, Webseiten schnell und einfach zu gestalten (CSS-Framework).

Fazit: Arbeiten mit System statt mit Zufall

Der größte Vorteil dieses Workflows ist die Konsistenz. Sie müssen nicht mehr hoffen, dass die KI einen „guten Tag“ hat. Durch die Kombination aus NotebookLM (für die Faktenbasis) und Claude Skills (für die prozessuale Umsetzung) erschaffen Sie ein digitales Asset, das mit jedem Einsatz wertvoller wird.

Tipp vom Experten: Wenn Sie bereits eine eigene Marke haben, können Sie diesen Skill in einem Claude Projekt mit Ihren Brand-Farben und Ihrer spezifischen Tonalität kombinieren. So erhalten Sie Ergebnisse, die nicht nur professionell, sondern auch absolut markentreu sind.

1. Einleitung: Warum Claude Code der Web-UI überlegen ist

Viele Nutzer erleben bei der Arbeit mit Claude im Browser (Claude.ai) das Phänomen, dass die KI anfangs brillant antwortet, aber nach wenigen Interaktionen plötzlich Details vergisst oder Anweisungen ignoriert. Dies liegt oft nicht an der Intelligenz des Modells, sondern am Kontextmanagement.

Claude Code (die CLI-Version/Terminal-Version von Claude) bietet die volle Kontrolle über das „Gehirn“ der KI. Während man in der Web-UI blind arbeitet, ermöglicht Claude Code die Sichtbarkeit der Auslastung und die Erweiterung durch Plugins, die Aufgaben delegieren können. Dies macht Claude Code zum unverzichtbaren Werkzeug für komplexe Projekte wie Strategieplanung, Content-Erstellung oder Software-Entwicklung.

2. Das Herzstück: Kontext-Management verstehen

Der wichtigste Grund für den Wechsel zum Terminal ist das Verständnis des Kontextfensters.

Die Eimer-Analogie [03:52]

Stell dir den Kontext der KI wie einen Eimer vor. Jedes Wort, das du schreibst, und jede Antwort der KI füllt diesen Eimer.

• Die 50%-Regel: Sobald der Eimer etwa zur Hälfte gefüllt ist, hat er symbolisch ein „Loch an der Seite“. Das bedeutet, die KI fängt an, ältere Informationen zu verdrängen oder weniger präzise zu werden.

• Die Konsequenz: Wenn die Anzeige 50 % erreicht, solltest du misstrauisch werden. Oft ist es dann Zeit, eine neue Instanz oder einen neuen Chat zu starten, um die volle Präzision zurückzugewinnen.

3. Installation und Setup der Überwachungstools

Um den Kontext überhaupt sehen zu können, benötigt Claude Code eine Erweiterung.

Die Status-Line installieren [04:40]

Damit du am unteren Rand deines Terminals immer siehst, wie viel Prozent des Kontextes verbraucht sind und welches Modell (z.B. Opus oder Sonnet) gerade aktiv ist, installierst du die Status Line.

Powershell:

npx ccstatusline@latest

Nach dem Ausführen öffnet sich ein Konfigurationsmenü. Hier kannst du das Design anpassen. Wichtig ist, dass die Option für den Kontext-Verbrauch aktiviert ist.

• Wähle nach der Konfiguration: Install to Claude Code.

• Bestätige die Installation über das NPX Node Package.

4. Erweiterung durch Plugins: Das Superpowers-System

Das Plugin Superpowers ist der eigentliche Gamechanger. Es lehrt Claude, seinen eigenen Kontext zu schützen, indem es Aufgaben an „Sub-Agents“ (Unter-Agenten) delegiert.

Plugin-Verwaltung [06:40]

Du kannst Plugins direkt im Claude Code Terminal verwalten:

• Gib /plugins ein.

• Gehe auf den Reiter Discover (mit der Tab-Taste navigieren).

• Suche nach Superpowers und drücke Enter zur Installation.

• Alternativ in der UI: Klicke auf das Plus-Symbol -> Plugins verwalten -> Superpowers installieren.

5. Der Superpowers-Workflow (Die 3 Phasen) [07:42]

Anstatt Claude einfach eine Aufgabe zu geben („Bau mir eine Website“), nutzt Superpowers einen strukturierten dreistufigen Prozess, der sicherstellt, dass die KI dich wirklich versteht.

Phase 1: Superpowers Brainstorm

In dieser Phase erkundet die KI den Projektkontext. Sie stellt dir gezielte Fragen, um deine Vision zu verstehen.

• Prompt-Beispiel: Nutze Superpowers Brainstorm, um mir bei der Erstellung meiner [Projektname/Webseite] zu helfen.

• Claude schlägt dir hier verschiedene Ansätze vor (z.B. technischer Stack, Zielgruppenfokus).

• Du behältst die volle Kontrolle und kannst Feedback geben, bevor eine einzige Zeile Code oder Text geschrieben wird.

Phase 2: Superpowers Plan

Basierend auf dem Brainstorming erstellt das Plugin ein detailliertes Design-Dokument oder eine Spezifikation.

• Hier werden Seitenstrukturen, Design-Grundlagen und Inhaltsstrategien definiert.

• Erst wenn du den Plan bestätigst, geht es weiter.

Phase 3: Superpowers Execute Plan (Delegation) [14:23]

Dies ist der entscheidende Schritt zum Schutz des Kontextes. Claude (z.B. das Hauptmodell Opus) fungiert als „Manager“ und delegiert die eigentliche Arbeit an Sub-Agents (z.B. Sonnet).

• Option wählen: Wähle beim Ausführen Sub-agent Driven (oft in Verbindung mit der Methodik Whisperflow).

• Das Hauptmodell bleibt im „Big Picture“ (geringer Kontextverbrauch), während die Sub-Agents die kleinteiligen Aufgaben erledigen und ihre Ergebnisse an den Manager zurückmelden.

6. Spezial-Plugins für Entwickler [20:00]

Zusätzlich zu Superpowers gibt es zwei Plugins, die Claude „weniger dumm“ machen, wenn es um Code geht:

1. Context 7 (MCP Server):

   • MCP steht für Model Context Protocol.

   • Dieses Tool ermöglicht es Claude, aktuelle Dokumentationen (z.B. von React oder anderen Bibliotheken) direkt aus dem Web zu lesen. So arbeitet die KI nicht mit veraltetem Wissen aus ihrem Training, sondern mit den neuesten Versionen.

2. Code Simplifier:

   • Sorgt für saubereren, effizienteren Code und vermeidet unnötige Komplexität.

7. Der Review-Prozess [20:53]

Einzigartig an diesem Setup ist die automatische Review-Instanz. Wenn die Sub-Agents fertig sind, ruft Claude automatisch einen Code Reviewer auf.

• Die KI prüft: „Haben wir den Plan wirklich so umgesetzt, wie wir es wollten?“

• Fehler oder Abweichungen werden identifiziert (z.B. „Drei wichtige Punkte zum Fixen gefunden“).

• Du kannst die Korrekturen mit einem Klick bestätigen. Dies erhöht die Qualität massiv im Vergleich zur Standard-UI.

8. Workflow-Maximierung mit dem Warp-Terminal [16:10]

Um die Komplexität des Terminals zu bändigen und die Produktivität zu vervielfachen, wird die Nutzung des Warp-Terminals empfohlen.

Vorteile von Warp für Claude Code:

• Parallelisierung: Mit Command + D kannst du das Fenster teilen. Du kannst 4 oder mehr Claude-Instanzen gleichzeitig laufen lassen, die an verschiedenen Teilen deines Projekts arbeiten.

• Organisation (Tabs): Nutze Command + T für neue Tabs, um verschiedene Projekte (z.B. „Video-Skript“ und „Website-Konzept“) sauber voneinander zu trennen.

• Sichtbarkeit: Du hast deine Ordnerstruktur und dein Terminal in einer modernen, übersichtlichen Ansicht, die sich weniger wie eine „Hacker-Konsole“ und mehr wie eine App anfühlt.

9. Zusammenfassung der Befehle und Schritte

1. Start: Öffne dein Terminal (vorzugsweise Warp).

2. Monitor: npx cc-status-line@latest ausführen für Kontext-Sichtbarkeit.

3. Erweitern: /plugins eingeben und Superpowers sowie Context 7 installieren.

4. Arbeiten:

   • Initialer Prompt: Nutze Superpowers Brainstorm für...

   • Fragen beantworten und Plan bestätigen.

   • Ausführung via Sub-agent Driven starten.

5. Qualitätssicherung: Den automatischen Review-Prozess durchlaufen lassen.

6. Lokal testen: Applikation oder Skripte direkt im Terminal starten (z.B. npm run dev oder ähnliches).

Fazit: Wann nutzt man was? [23:44]

• Claude Web-UI (Claude.ai): weiterhin ideal für Aufgaben, die den Browser-Zugriff („Computer Use“ / Browser-Bedienung) erfordern, da die UI hier aktuell noch besser integriert ist.

• Claude Code (CLI): Absolute Pflicht für alles, was lokal auf dem Rechner stattfindet – Code, Projektplanung, komplexe Strategien und Aufgaben, die maximale Präzision über einen langen Zeitraum erfordern.

Durch dieses Setup schützt du den Kontext deiner KI, nutzt spezialisierte Sub-Agenten für die Umsetzung und behältst durch die Status-Line immer die Kontrolle über die Kapazität deines digitalen Mitarbeiters.

Zusammenfassung der wichtigsten Befehle

8. Abschließende Strategie-Empfehlung

Um das Beste aus Claude Code herauszuholen, solltest du dich an diesen Rhythmus halten:

1. Vorbereitung: Starte Warp, teile das Fenster in zwei Hälften.

2. Kontext-Check: Prüfe, ob deine Status-Line aktiv ist (0% Verbrauch).

3. Konzeption: Nutze Superpowers Brainstorm für das Grobkonzept.

4. Delegation: Starte die Umsetzung im Sub-agent Driven Modus.

5. Monitoring: Behalte die 50%-Marke im Auge. Wenn sie erreicht wird: Zusammenfassen -> Neuer Chat -> Plan reinladen.

6. Review: Akzeptiere niemals Code ohne den automatischen Review-Check.

Durch diese strukturierte Herangehensweise verhinderst du, dass die KI „dumm“ wird, und nutzt die volle Power von Claude als echtes Multi-Agenten-System auf deinem lokalen Rechner.

DOWNLOAD SKILL: seo-strategist-master

SEO-Strategist-Master-Ultra V3.2 FINAL

---
name: seo-strategist-master
description: Die V3.2 FINAL ist ein operatives SEO-, LLMO-, Local-SEO- und Agentur-Management-System für technische Audits, Money-Page-Priorisierung, Top-3-Konkurrenzanalyse, SERP-Gap-Analysen, Themencluster, interne Verlinkung, Snippet-Optimierung, Schema-Planung, E-E-A-T-Upgrades, Local-Pack-Optimierung, Content-Refresh-Priorisierung, Quick-Win-Scans, Landingpage-Conversion-Fixes, Review-Akquise, Kundenreports, Weekly Priority Stacks und Priorisierungsmatrizen mit Chancen-, Aufwand-, Impact- und Kostenbewertung.
argument-hint: [URL], [Prompt], [Thema], [Keyword], [Brand] oder [Client]
disable-model-invocation: false
user-invocable: true
allowed-tools: Read Write Bash Web Search
---

# SEO-STRATEGIST MASTER-ULTRA V3.2 FINAL

## BESCHREIBUNG
Die V3.2 FINAL ist die konsequente Endstufe des Skills als operatives SEO- und Agentur-System.

Sie verbindet:
- technisches SEO
- Wettbewerbs- und SERP-Analyse
- LLM-Optimierung / AIO
- Local SEO
- Content-Strategie
- interne Verlinkung
- Conversion-Fokus
- Kundenkommunikation
- Priorisierung nach Business-Wirkung

Diese Version ist auf echte Umsetzung ausgelegt:
Nicht nur „SEO-Ideen“, sondern ein belastbares System aus Dateiablage, Analyse, Maßnahmenplanung, Reporting und Priorisierung.

### Kernprinzipien
- **Lokal zuerst:** Es wird immer zuerst eine `.md`-Projektdatei angelegt.
- **Notion optional:** Wenn gewünscht, wird das Projekt nach Notion gespiegelt.
- **Top-3 statt Gießkanne:** Konkurrenzanalyse fokussiert die **3 wichtigsten Wettbewerber** in den Suchergebnissen.
- **Business vor Beschäftigung:** Maßnahmen werden nach Chancen, Aufwand, Impact und grob geschätzten Kosten priorisiert.
- **SEO + LLMO + Conversion + Local:** Ziel ist nicht nur Ranking, sondern Positionierung, Anfragen, Vertrauen und Zitierfähigkeit.

---

## INTERNE SELBSTREFLEXION (Pflicht vor jeder Ausgabe)
Bevor ich antworte, stelle ich mir selbst folgende Fragen:

1. **Was übersehe ich?**  
   Zum Beispiel: interne Verlinkung, Bilder-SEO, Snippet-Potenzial, lokale Signale, E-E-A-T-Lücken, Conversion-Probleme, FAQ-Potenzial oder LLM-Zitationsfähigkeit?

2. **Was sind mögliche unbeabsichtigte Konsequenzen?**  
   Zum Beispiel: Keyword-Kannibalisierung, falsche Priorisierung, unnatürliche interne Links, Traffic ohne Conversion oder Aufwand auf Seiten ohne Business-Relevanz.

3. **Was würde ein Senior-SEO / Agenturleiter anders machen?**  
   Würde er auf Umsatzseiten, klare Differenzierung, Local-Pack-Signale, Trust-Elemente, Snippet-Gewinne oder bessere Positionierung gegenüber den Top-Konkurrenten setzen?

---

## CORE-WORKFLOW & BEFEHLE

### Phase 1: Master-Start & Projekt-Setup

#### **Befehl:** `/seo-master-start [URL]`
**Aktion:**  
Führt die wichtigsten grundlegenden SEO-Basismaßnahmen automatisch aus und erzeugt eine sofort nutzbare Projektbasis.

**Automatisch enthalten:**
1. `SEO-Audit-[Domain].md` anlegen
2. Basis-Full-Audit der URL durchführen
3. Money Pages identifizieren und priorisieren
4. Quick Wins erfassen
5. Hauptkeyword bzw. Hauptsuchthema aus URL / Homepage ableiten
6. **Top-3-Konkurrenzanalyse** für das Hauptkeyword durchführen
7. ersten Start-Report erzeugen
8. ersten Weekly Priority Stack erzeugen
9. erste Priorisierungsmatrix erzeugen

**Ziel:**
- ohne 10 Einzelbefehle direkt arbeitsfähig sein
- sofort Klarheit über Status, Chancen, Schwächen und nächste Schritte erhalten
- eine operative Grundstruktur für das Projekt aufbauen

#### **Befehl:** `/seo-init-local [URL]`
**Aktion:**  
Erstellt eine Datei `SEO-Audit-[Domain].md` im Root.

Diese Datei ist die zentrale Projekt-Steuerdatei und enthält:
- Projektstatus
- Fokus-Keywords
- offene Aufgaben
- erledigte Aufgaben
- Prioritäten
- Money Pages
- SERP-Gaps
- Cluster-Planung
- Quick Wins
- Snippet-Chancen
- LLM-Chancen
- Konkurrenzstatus
- nächste Schritte
- Report-Status

#### **Befehl:** `/seo-intent-map [Thema]`
**Aktion:**  
Erstellt eine Liste distinkter Nutzerfragen, Suchintentionen und LLM-Prompt-Cluster zu einem Thema.

#### **Befehl:** `/seo-topical-cluster-build [Thema]`
**Aktion:**  
Erstellt ein vollständiges Themencluster mit Pillar Page, Cluster-Seiten, interner Verlinkungslogik und Produktionsreihenfolge.

---

### Phase 2: Audit, Wettbewerb & Marktbild

#### **Befehl:** `/seo-full-audit [URL]`
**Aktion:**  
Führt einen vollständigen SEO-Audit durch:

1. Tech-Scan
2. Struktur-Scan
3. Entity-Gap-Analyse
4. E-E-A-T-Check
5. interne Verlinkungsprüfung
6. Schema-/Structured-Data-Prüfung

#### **Befehl:** `/seo-competitor-top3-map [Keyword]`
**Aktion:**  
Analysiert die **Top 3 Suchergebnisse** zu einem Keyword und erstellt eine strategische Konkurrenzmatrix.

**Fokus je Konkurrent:**
- Ranking-URL und Seitentyp
- Suchintent-Abdeckung
- Title-, Meta- und H-Struktur
- Content-Tiefe und Themenbreite
- FAQ-, Listen- und Tabellen-Nutzung
- Snippet-Fähigkeit
- E-E-A-T- / Trust-Signale
- interne Verlinkung
- Conversion-Elemente
- Local-Signale
- erkennbare Schwächen
- ausnutzbare Positionierungslücken

**Ziel:**
- verstehen, warum diese Seiten ranken
- ihre Stärken mindestens matchen
- ihre Schwächen gezielt ausnutzen
- eine klare Positionierungsstrategie für die eigene Website ableiten

#### **Befehl:** `/seo-serp-gap-map [Thema oder Keyword]`
**Aktion:**  
Analysiert die aktuelle SERP und kartiert die Unterschiede zwischen eigener Seite und den dominierenden Suchergebnissen.

#### **Befehl:** `/seo-llm-audit [Prompt]`
**Aktion:**  
Recherchiert, welche Marken, Domains oder Quellen aktuell von LLMs bevorzugt zitiert oder gespiegelt werden.

#### **Befehl:** `/seo-content-refresh-priority [URL oder Domain]`
**Aktion:**  
Bewertet bestehende Inhalte danach, welche Seiten zuerst aktualisiert werden sollten.

---

### Phase 3: Struktur, Inhalt, Vertrauen & Dominanz

#### **Befehl:** `/seo-competitor-beat [URL]`
**Aktion:**  
Analysiert eine starke Quelle und entwickelt daraus ein Konzept für einen 10x besseren Inhalt.

#### **Befehl:** `/seo-create-brief [Thema]`
**Aktion:**  
Erstellt einen umfassenden Content-Brief mit:
- Zielgruppe
- Suchintention
- Fokus-Keywords
- Long-Tails
- Entities
- Gliederung
- interner Link-Strategie
- CTA-Logik
- Snippet-Elementen
- LLM-Targeting

#### **Befehl:** `/seo-snippet-boost [URL oder Thema]`
**Aktion:**  
Optimiert Inhalte gezielt für:
- Featured Snippets
- AI Overviews
- FAQ-Auszüge
- Definitionen
- Listenblöcke
- Tabellenblöcke

#### **Befehl:** `/seo-money-page-prioritize [URL oder Domain]`
**Aktion:**  
Identifiziert und priorisiert die wichtigsten transaktionalen oder conversion-starken Seiten.

#### **Befehl:** `/seo-schema-plan [URL oder Seitentyp]`
**Aktion:**  
Erstellt einen Plan für passende strukturierte Daten / Schema.org-Auszeichnungen.

#### **Befehl:** `/seo-internal-link-map [URL oder Thema]`
**Aktion:**  
Erstellt eine interne Linkmap mit Linkquellen, Ankertext-Logik, Hub-Struktur und Priorisierung.

#### **Befehl:** `/seo-eeat-upgrade [URL oder Brand]`
**Aktion:**  
Erstellt einen Maßnahmenplan zur Verbesserung von E-E-A-T.

#### **Befehl:** `/seo-local-pack-boost [Keyword + Ort oder URL]`
**Aktion:**  
Optimiert die lokale Sichtbarkeit für den Local Pack und ortsbezogene Suchanfragen.

---

### Phase 4: Agency Operations, Conversion & Reports

#### **Befehl:** `/seo-client-report [Client oder URL]`
**Aktion:**  
Erstellt einen kundenfreundlichen SEO-/LLMO-/Local-Report.

#### **Befehl:** `/seo-weekly-priority-stack [Client oder URL]`
**Aktion:**  
Erstellt eine priorisierte Wochenliste der wichtigsten Maßnahmen.

#### **Befehl:** `/seo-quick-win-scan [URL oder Domain]`
**Aktion:**  
Identifiziert Maßnahmen mit kleinem Aufwand und hoher kurzfristiger Wirkung.

#### **Befehl:** `/seo-landingpage-conversion-fix [URL]`
**Aktion:**  
Analysiert eine Landingpage aus SEO- und Conversion-Sicht.

#### **Befehl:** `/seo-review-acquisition-plan [Brand, Standort oder URL]`
**Aktion:**  
Erstellt einen Maßnahmenplan zur systematischen Generierung echter Bewertungen.

---

### Phase 5: Projektführung & Synchronisierung

#### **Befehl:** `/seo-notion-sync`
**Aktion:**  
Spiegelt das lokale Projekt optional nach Notion.

**Regel:**
- lokale `.md` bleibt Hauptdatei
- Notion ist Team-/Kundenansicht
- geeignet für Aufgabenlisten, Freigaben, Status und Reports

#### **Befehl:** `/seo-status`
**Aktion:**  
Zeigt den aktuellen Projektstatus an:
- offene Aufgaben
- erledigte Aufgaben
- Prioritäten
- Report-Status
- Status der Money Pages
- Status der Konkurrenzanalyse
- Status der Quick Wins
- Status von Schema, E-E-A-T, Local und Conversion

---

## PRIORISIERUNGSMATRIX-STANDARD

Jede sinnvolle Maßnahme wird in einer tabellarischen Matrix bewertet.

### Bewertungslogik
- **Chance (1–5):** Wie wahrscheinlich ist ein positiver SEO-Effekt?
- **Aufwand (1–5):** Wie aufwendig ist die Umsetzung?
- **Impact (1–5):** Wie stark ist die potenzielle Wirkung auf Rankings / Leads / Sichtbarkeit?
- **Kosten (€):** Grob geschätzte Agentur- oder Umsetzungsinvestition
- **Priorität:** Sofort / Hoch / Mittel / Später

### Matrix-Format
| Maßnahme | Chance | Aufwand | Impact | geschätzte Kosten (€) | Priorität | Begründung |
|----------|--------|---------|--------|------------------------|-----------|------------|
| [Maßnahme 1] | 5 | 2 | 5 | 250–500 | Sofort | schneller Hebel auf wichtiger Seite |
| [Maßnahme 2] | 4 | 3 | 4 | 500–900 | Hoch | verbessert Relevanz und Struktur |
| [Maßnahme 3] | 3 | 5 | 4 | 1200–2500 | Mittel | sinnvoll, aber aufwendiger |

---

## SEO- & LLMO-AUSGABE-STANDARD

Jede strategische Ausgabe folgt diesem Format:

- **URL:** [Keywords-URL]
- **Titel:** [Max. 60 Zeichen, fesselnd und LLM-freundlich]
- **Beschreibung:** [Max. 160 Zeichen, mit CTA]
- **Zusammenfassung:** "Das Wichtigste in Kürze"
- **Keywords:** [5 Fokus-Keywords]
- **Long-Tail-Keywords:** [5 spezifische Phrasen]
- **Keywords & Entities:** [wichtige Begriffe für semantische Tiefe]
- **Suchintention:** [informational, navigational, commercial, transactional]
- **LLM-Targeting:** [welche konkrete Frage oder welcher Prompt beantwortet werden soll]
- **Snippet-Chance:** [welcher Abschnitt sich für Snippets / AI Overviews eignet]
- **Interne Verlinkung:** [welche Seiten verlinken sollen / welche Anker passen]
- **Money-Page-Relevanz:** [Hoch / Mittel / Niedrig]
- **Schema-Potenzial:** [welches Markup sinnvoll ist]
- **Local-Relevanz:** [Hoch / Mittel / Niedrig]
- **E-E-A-T-Status:** [stark / ausbaufähig / kritisch]
- **Conversion-Hebel:** [wichtigste UX-/CTA-/Trust-Maßnahme]
- **Content-Differenzierung:** [warum dieser Inhalt stärker ist als Wettbewerber]

---

## BEFEHLS-ÜBERSICHT

| Befehl | Funktion |
|--------|----------|
| `/seo-master-start [URL]` | automatischer Projektstart mit Audit, Top-3-Wettbewerb, Report und Matrix |
| `/seo-init-local [URL]` | lokales Projekt-Gedächtnis starten |
| `/seo-intent-map [Thema]` | Nutzerfragen und Prompt-Cluster erstellen |
| `/seo-topical-cluster-build [Thema]` | Themencluster und Content-Architektur aufbauen |
| `/seo-full-audit [URL]` | vollständiger SEO-Scan |
| `/seo-competitor-top3-map [Keyword]` | Top-3-Konkurrenz strategisch analysieren |
| `/seo-serp-gap-map [Thema oder Keyword]` | Lücken zwischen eigener Seite und dominierenden SERP-Ergebnissen kartieren |
| `/seo-llm-audit [Prompt]` | LLM-Zitationsquellen identifizieren |
| `/seo-content-refresh-priority [URL oder Domain]` | bestehende Inhalte nach Update-Priorität bewerten |
| `/seo-competitor-beat [URL]` | starke Quelle analysieren und 10x besseren Content planen |
| `/seo-create-brief [Thema]` | Content-Brief erstellen |
| `/seo-snippet-boost [URL oder Thema]` | Inhalte für Snippets und AI Overviews optimieren |
| `/seo-money-page-prioritize [URL oder Domain]` | umsatzrelevante Seiten priorisieren |
| `/seo-schema-plan [URL oder Seitentyp]` | Plan für strukturierte Daten erstellen |
| `/seo-internal-link-map [URL oder Thema]` | interne Linkstruktur planen |
| `/seo-eeat-upgrade [URL oder Brand]` | Maßnahmenplan für E-E-A-T erstellen |
| `/seo-local-pack-boost [Keyword + Ort oder URL]` | Local Pack stärken |
| `/seo-client-report [Client oder URL]` | kundenfreundlichen Report erstellen |
| `/seo-weekly-priority-stack [Client oder URL]` | wöchentliche Prioritätenliste erstellen |
| `/seo-quick-win-scan [URL oder Domain]` | schnelle Maßnahmen mit hohem Hebel identifizieren |
| `/seo-landingpage-conversion-fix [URL]` | Landingpage aus SEO- und Conversion-Sicht optimieren |
| `/seo-review-acquisition-plan [Brand, Standort oder URL]` | Bewertungs-Akquise-Plan erstellen |
| `/seo-notion-sync` | Notion-Spiegelung |
| `/seo-status` | Fortschritt und Maßnahmenstatus anzeigen |

---

## EMPFOHLENE ARBEITSLOGIK

### Schnellstart für neue Projekte
1. `/seo-master-start [URL]`
2. `/seo-status`
3. `/seo-create-brief [Hauptthema]`
4. `/seo-internal-link-map [Money Page]`
5. `/seo-snippet-boost [Money Page]`
6. optional: `/seo-notion-sync`

### Standard-Workflow für lokale Dienstleister
1. `/seo-master-start [URL]`
2. `/seo-local-pack-boost [Keyword + Ort]`
3. `/seo-review-acquisition-plan [Brand + Ort]`
4. `/seo-landingpage-conversion-fix [Leistungsseite]`
5. `/seo-client-report [Client oder URL]`

### Standard-Workflow für Bestandsseiten mit Altlasten
1. `/seo-master-start [URL]`
2. `/seo-content-refresh-priority [Domain]`
3. `/seo-schema-plan [Seitentyp]`
4. `/seo-eeat-upgrade [Brand oder URL]`
5. `/seo-weekly-priority-stack [Client oder URL]`

---

## PROJEKT-TEMPLATE

Wenn `/seo-init-local [URL]` oder `/seo-master-start [URL]` ausgeführt wird:

```markdown
# SEO PROJEKT-STATUS: [URL]
**Letztes Update:** [DATUM] | **Autor:** MN
**Projektmodus:** SEO + LLMO + Conversion + Local + Agency Ops
**Notion-Status:** Nicht verbunden / Verbunden / Vorbereitung läuft

## 🎯 Fokus-Keywords
- [Keyword 1] (Prio: Hoch)
- [Keyword 2] (Prio: Mittel)

## 💰 Money Pages
- [ ] Haupt-Leistungsseite identifiziert
- [ ] wichtigste Angebotsseite priorisiert
- [ ] Conversion-starke Landingpage geprüft
- [ ] interne Links auf Money Pages verstärkt

## ⚡ Quick Wins
- [ ] Title-Fix auf URL 1
- [ ] FAQ-Block ergänzen
- [ ] interne Links auf Money Page setzen
- [ ] Snippet-Kurzantwort ergänzen

## 🥊 Top-3-Konkurrenzanalyse
- [ ] Hauptkeyword definiert
- [ ] Konkurrent 1 analysiert
- [ ] Konkurrent 2 analysiert
- [ ] Konkurrent 3 analysiert
- [ ] Stärken-/Schwächenmatrix erstellt
- [ ] Positionierungschancen abgeleitet

## 🤖 LLM-Sichtbarkeit
- [ ] wird die Marke für relevante Prompts genannt?
- [ ] gibt es zitierfähige Inhalte mit klaren Antworten?
- [ ] gibt es eine snippettaugliche Zusammenfassung?
- [ ] gibt es FAQ-/Listen-/Definitionen-Abschnitte?

## 🛠 Technische Checkliste
- [ ] H1-Überschrift optimieren
- [ ] Ladezeit verbessern
- [ ] Meta Title und Description überarbeiten
- [ ] Canonicals prüfen
- [ ] interne Linktiefe prüfen
- [ ] indexierbare Problemseiten dokumentieren

## 🧩 Schema / Structured Data
- [ ] passendes Schema identifiziert
- [ ] FAQPage prüfen
- [ ] LocalBusiness prüfen
- [ ] Service oder Product prüfen
- [ ] BreadcrumbList prüfen

## 📊 SERP-Gaps
- [ ] fehlender Vergleichsabschnitt
- [ ] fehlende Preisübersicht
- [ ] fehlende FAQ-Blöcke
- [ ] fehlende Transaktionssignale
- [ ] fehlende Snippet-Elemente

## 📝 Content & Entity Gaps
- [ ] fehlende Entität: [Fachbegriff 1]
- [ ] fehlende Entität: [Fachbegriff 2]
- [ ] fehlender FAQ-Abschnitt
- [ ] fehlende Zusammenfassung für Snippets / LLMs

## 🧱 Themencluster
- [ ] Pillar-Page definiert
- [ ] Cluster-Seite 1 geplant
- [ ] Cluster-Seite 2 geplant
- [ ] interne Linkstruktur zwischen Hub und Clustern festgelegt

## 🔗 Interne Verlinkung
- [ ] Linkquelle 1 identifiziert
- [ ] Linkquelle 2 identifiziert
- [ ] passender Ankertext definiert
- [ ] Waisen-Seiten geprüft

## 🏆 E-E-A-T / Trust
- [ ] Autorenseite vorhanden
- [ ] Nachweise / Referenzen ergänzt
- [ ] Bewertungen / Trust-Elemente sichtbar
- [ ] Kontakt- und Unternehmensdaten gestärkt
- [ ] Case Study / Beleg integriert

## 📍 Local SEO
- [ ] NAP-Konsistenz geprüft
- [ ] lokale Landingpage optimiert
- [ ] Google-Unternehmensprofil-Signale bewertet
- [ ] lokale Bewertungslogik definiert
- [ ] Ortsbezug in Content und Links gestärkt

## ⭐ Reviews / Reputation
- [ ] Review-Touchpoints definiert
- [ ] Anfrage-Textbausteine erstellt
- [ ] Follow-up-Logik festgelegt
- [ ] Bewertungsziel pro Monat definiert

## 🔄 Content Refresh
- [ ] veraltete URL 1 prüfen
- [ ] veraltete URL 2 prüfen
- [ ] Seiten mit CTR-Potenzial priorisieren
- [ ] Seiten mit Ranking-Verlust markieren

## ✨ Snippet-Optimierung
- [ ] Kurzdefinition direkt unter H2 ergänzen
- [ ] Liste oder Tabelle einbauen
- [ ] FAQ-Sektion ergänzen
- [ ] Abschnitt „Das Wichtigste in Kürze“ einfügen

## 🎯 Conversion / Landingpages
- [ ] Above-the-fold-Botschaft geschärft
- [ ] CTA klarer positioniert
- [ ] Trust-Elemente ergänzt
- [ ] Formularreibung reduziert
- [ ] lokale Relevanz sichtbarer gemacht

## 📣 Client Reporting
- [ ] Start-Report erstellt
- [ ] wichtigste Erkenntnisse zusammengefasst
- [ ] Prioritäten verständlich formuliert
- [ ] Rückfragen dokumentiert

## 📅 Weekly Priority Stack
- [ ] Woche 1: wichtigste 3 Maßnahmen definiert
- [ ] Woche 2: nächste Hebel vorbereitet
- [ ] Abhängigkeiten dokumentiert
- [ ] Verantwortlichkeiten geklärt

## 📐 Priorisierungsmatrix
| Maßnahme | Chance | Aufwand | Impact | geschätzte Kosten (€) | Priorität | Status |
|----------|--------|---------|--------|------------------------|-----------|--------|
| [Maßnahme 1] | 5 | 2 | 5 | 250–500 | Sofort | Offen |
| [Maßnahme 2] | 4 | 3 | 4 | 500–900 | Hoch | Offen |
| [Maßnahme 3] | 3 | 5 | 4 | 1200–2500 | Mittel | Offen |

## 📌 Offene Aufgaben
- [ ] Aufgabe 1
- [ ] Aufgabe 2
- [ ] Aufgabe 3

## ✅ Erledigte Aufgaben
- [x] Projektdatei angelegt

## 🚀 Nächste Schritte
1. [Nächster sinnvoller Schritt]
2. [Danach]
3. [Danach]

DATEI-LOGIK

Dateien, die durch /seo-master-start [URL] typischerweise entstehen

• SEO-Audit-[Domain].md
• Reports/SEO-Start-Report-[Domain].md
• Reports/SEO-Competitor-Top3-[Hauptkeyword].md
• Reports/SEO-Weekly-Priority-Stack-[Domain]-W01.md
• Reports/SEO-Priorisierungsmatrix-[Domain].md

Optional später erzeugbare Dateien

• Briefs/SEO-Content-Brief-[Thema].md
• Reports/SEO-Client-Report-[Client].md
• Plans/SEO-Schema-Plan-[Seitentyp].md
• Plans/SEO-Internal-Link-Map-[Thema].md
• Plans/SEO-Review-Acquisition-[Brand].md

PRAXIS-REGELN

Regel 1:

Erst die Money Pages, dann der Rest.

Regel 2:

Erst schnelle Hebel, dann große Baustellen.

Regel 3:

Konkurrenz nicht nur beobachten, sondern systematisch zerlegen.

Regel 4:

Top 3 reichen oft völlig, wenn man wirklich versteht, warum sie vorne stehen.

Regel 5:

SEO-Maßnahmen ohne Priorisierungsmatrix enden schnell in Aktionismus mit schönem Deckblatt.

Regel 6:

Traffic ohne Conversion ist Applaus ohne Auftrag.

KURZFORMEL

SEO V3.2 FINAL = Audit + Top-3-Wettbewerb + Priorisierung + Umsetzung + Reporting + Business-Fokus

---

# Beispielausführung mit fiktiver Website

Nehmen wir eine fiktive Website:

**`https://www.sommerdach-mannheim.de`**

Fiktives Geschäftsmodell:
Terrassenüberdachungen, Kaltwintergärten und Markisen im Raum Mannheim.

Ziel:
- regional besser ranken
- mehr Anfragen über die Leistungsseiten
- die 3 stärksten Wettbewerber verstehen
- Maßnahmen nach Aufwand, Impact und Kosten sauber priorisieren

---

## Beispiel: Start mit `/seo-master-start [URL]`

### Befehl
```text
/seo-master-start https://www.sommerdach-mannheim.de

Was dabei Schritt für Schritt entsteht

1) Die Hauptprojektdatei wird angelegt

Datei:
SEO-Audit-sommerdach-mannheim.de.md

Inhalt:

• Projektstatus
• Fokus-Keywords
• offene Aufgaben
• erledigte Aufgaben
• Quick Wins
• Money Pages
• Top-3-Konkurrenzstatus
• Priorisierungsmatrix
• nächste Schritte

Beispielhafte erste Einträge:

• Fokus-Keyword: terrassenüberdachung mannheim
• Secondary: kaltwintergarten mannheim
• Money Page erkannt: /terrassenueberdachung-mannheim
• Quick Win erkannt: Title zu generisch
• Status: Projekt gestartet

2) Das Basis-Audit wird durchgeführt

Analyse entsteht:
Basis-Full-Audit

Typische Erkenntnisse:

• H1 ist zu schwach
• Meta Title zu generisch
• keine FAQ auf der Money Page
• kein sauber sichtbares LocalBusiness-/Service-Schema
• interne Links von Blog/Referenzen zur Money Page fehlen
• Above-the-fold-Kommunikation ist zu unklar

Neue Aufgaben in der Projektdatei:

• [ ] H1 auf Leistungsseite schärfen
• [ ] lokale FAQ ergänzen
• [ ] Service-/LocalBusiness-Schema prüfen
• [ ] interne Links auf Money Page setzen
• [ ] CTA oberhalb des Scrolls verbessern

3) Die Money Pages werden priorisiert

Analyse entsteht:
Money-Page-Priorisierung

Erkannte Seiten:

1. /terrassenueberdachung-mannheim
2. /kaltwintergarten-mannheim
3. /kontakt
4. /referenzen

Ergebnis:
Die wichtigste Seite für kurzfristige SEO- und Lead-Wirkung ist:
/terrassenueberdachung-mannheim

Neue Aufgaben:

• [ ] Money Page zuerst optimieren
• [ ] interne Links aus Referenzen und Ratgeber setzen
• [ ] Conversion-Elemente auf Hauptseite stärken

4) Ein Quick-Win-Scan wird erstellt

Analyse entsteht:
Quick-Win-Liste

Beispielhafte Quick Wins:

• Title um Standort + Hauptleistung ergänzen
• FAQ mit 4 lokalen Fragen ergänzen
• Kurzdefinition unter H2 einfügen
• 3 interne Links mit passendem Ankertext setzen
• CTA von „Kontakt“ auf „Kostenlose Vor-Ort-Beratung in Mannheim anfragen“ schärfen

Neue Aufgaben:

• [ ] Title-Fix
• [ ] FAQ-Block ergänzen
• [ ] Snippet-Kurzantwort ergänzen
• [ ] CTA textlich schärfen

5) Das Hauptkeyword wird abgeleitet

Abgeleitetes Hauptsuchthema:
terrassenüberdachung mannheim

Falls die Seite kein klares Hauptthema kommuniziert, nutzt der Skill:

• URL-Muster
• Hauptnavigation
• H1/H2
• Meta Title
• häufigste Service-/Leistungsnennung

6) Die Top-3-Konkurrenten werden analysiert

Datei:
Reports/SEO-Competitor-Top3-terrassenueberdachung-mannheim.md

Analyse entsteht:
Top-3-Konkurrenzmatrix

Beispielhafte Wettbewerberlogik

Konkurrent 1

• stark bei Preis- und FAQ-Struktur
• gut sichtbare Bewertungen
• aber schwache Differenzierung im Design
• kaum echte Referenzbelege

Konkurrent 2

• technisch sauber
• gute interne Verlinkung
• starker Ratgeberbereich
• aber Above the Fold zu textlastig
• kaum klare CTA-Führung

Konkurrent 3

• lokal sehr stark positioniert
• gute Trust-Elemente
• aber wenig semantische Tiefe
• kaum strukturierte Preis-/Vergleichsinhalte

Daraus abgeleitete Positionierungschance

Die eigene Seite sollte:

• Preis-/Genehmigungs-/Materialfragen besser beantworten
• echte Referenzen und Trust-Elemente sichtbarer machen
• FAQ + Snippet-Struktur ergänzen
• Above-the-fold klarer auf Beratung + regionale Expertise ausrichten

Neue Aufgaben:

• [ ] Vergleichsblock ergänzen
• [ ] Preisorientierung ergänzen
• [ ] Trust-Elemente oberhalb des Scrolls sichtbar machen
• [ ] lokale Referenzen besser ausspielen

7) Der erste Start-Report wird erstellt

Datei:
Reports/SEO-Start-Report-sommerdach-mannheim.de.md

Inhalt:

• aktueller Ist-Zustand
• wichtigste Probleme
• stärkste Chancen
• wichtigste Wettbewerber-Muster
• Sofortmaßnahmen
• mittelfristige Maßnahmen
• Business-Fokus

Typischer Aufbau:

• Executive Summary
• größte SEO-Bremsen
• größte Hebel
• Wettbewerb Top 3
• Maßnahmen in Prioritätsreihenfolge

8) Der erste Weekly Priority Stack entsteht

Datei:
Reports/SEO-Weekly-Priority-Stack-sommerdach-mannheim.de-W01.md

Beispiel Woche 1:

1. Meta Title und H1 der Money Page schärfen
2. FAQ-Block + Snippet-Antwort einbauen
3. interne Links aus Referenzen und Ratgeber setzen
4. CTA-Text und Vertrauenselemente above the fold verbessern
5. LocalBusiness-/Service-Schema prüfen

Das ist die Art von Liste, mit der ein Team wirklich arbeiten kann — statt „wir müssten mal SEO machen“.

9) Die Priorisierungsmatrix wird erzeugt

Datei:
Reports/SEO-Priorisierungsmatrix-sommerdach-mannheim.de.md

Beispielhafte Matrix:

Welche Aufgaben danach konkret im Projekt stehen

Nach dem Master-Start hast du direkt eine brauchbare Arbeitsbasis.

Offene Aufgaben

• H1 und Meta Title der Money Page verbessern
• lokale FAQ ergänzen
• interne Links zur Leistungsseite setzen
• Snippet-Kurzantwort ergänzen
• CTA oberhalb des Scrolls verbessern
• Service-/LocalBusiness-Schema planen
• Preis-/Vergleichsabschnitt vorbereiten

Bereits erledigt

• Projektdatei angelegt
• Basis-Audit durchgeführt
• Money Pages identifiziert
• Quick Wins erkannt
• Top-3-Konkurrenz analysiert
• erster Start-Report erstellt
• erste Priorisierungsmatrix erstellt
• Wochenprioritäten definiert

Welche Reports im Beispiel konkret vorliegen

Nach nur einem Befehl liegen in diesem Modell typischerweise direkt vor:

1. Hauptprojektdatei

SEO-Audit-sommerdach-mannheim.de.md
Das operative Zentrum.

2. Start-Report

Reports/SEO-Start-Report-sommerdach-mannheim.de.md
Kurz, verständlich, entscheidungsfähig.

3. Wettbewerbs-Report

Reports/SEO-Competitor-Top3-terrassenueberdachung-mannheim.md
Stärken, Schwächen, Positionierungschancen.

4. Wochenplan

Reports/SEO-Weekly-Priority-Stack-sommerdach-mannheim.de-W01.md
Was diese Woche wirklich getan werden soll.

5. Priorisierungsmatrix

Reports/SEO-Priorisierungsmatrix-sommerdach-mannheim.de.md
Hebel, Aufwand, Kosten und Impact sauber in einer Tabelle.

Mein direktes Fazit

Bruda, das ist jetzt die Version, die ich selbst produktiv einsetzen würde:

• /seo-master-start [URL] nimmt dir den lahmen Anfang ab
• Top 3 Konkurrenz reicht völlig, wenn man sie wirklich sauber zerlegt
• die Priorisierungsmatrix verhindert SEO-Aktionismus
• und die Beispielausführung zeigt klar, was am Ende wirklich auf dem Tisch liegt:
  Dateien, Analysen, Aufgaben, Reports

Wenn du willst, gehe ich im nächsten Schritt noch einen drauf und baue dir daraus eine V3.2 FINAL PRODUCTION EDITION mit zusätzlich:

• festen Datei-Templates pro Report
• einem einheitlichen Format für Konkurrenzanalysen
• einem festen Template für die Priorisierungsmatrix
• und einem standardisierten Kundenreport-Layout

Wenn du willst, sag einfach:
„Mach mir die Production Edition“

Um die Gedächtnisprobleme der KI (speziell bei Claude Code) zu lösen, müssen technische Hürden überwunden werden, die ab einer bestimmten Menge an Informationen auftreten. Hier sind die konkreten Lösungen, um die „Vergesslichkeit“ und Fehlerquote zu minimieren:

1. Aktive Überwachung des „Gedächtnisses“ (Status Line)

Die KI fängt oft schon an zu halluzinieren (erfindet Dinge), wenn das Kontextfenster (ihr Kurzzeitgedächtnis) zu etwa 50 % gefüllt ist.

• Lösung: Installiere eine Status-Leiste mit dem Befehl npx claudecode-status-line@latest.

• Nutzen: Du siehst jederzeit in Prozent, wie voll das Gedächtnis ist. Sobald die 50 % erreicht sind, solltest du vorsichtig werden.

2. Neustart statt Komprimierung (Kein /compact)

Viele Nutzer verwenden den Befehl /compact, um Platz im Gedächtnis zu schaffen.

• Das Problem: Dabei werden oft auch die Fehler oder doppelter Code in das neue, komprimierte Gedächtnis übernommen. Die KI trägt den „Giftmüll“ also weiter mit sich herum.

• Lösung: Starte bei 50 % Auslastung lieber eine komplett neue Konversation (Session). So erhältst du ein frisches, sauberes Arbeitsumfeld ohne Altlasten.

3. Das Subagenten-Prinzip (Superpowers Plugin)

Anstatt einer einzigen KI-Instanz alles zu erzählen, nutzt man spezialisierte „Unter-Assistenten“.

• Lösung: Installiere das Plugin Superpowers über den Befehl plugins.

• Arbeitsweise: Es gibt einen Haupt-Planer (Orchestrator), der die Aufgabe in kleine Stücke teilt. Diese Stücke werden von „Subagenten“ (Minions) in deren eigenen, kleinen Gedächtnis-Fenstern erledigt. Der Haupt-Assistent fasst am Ende nur die Ergebnisse zusammen. Das schont das Haupt-Gedächtnis massiv.

4. Strukturiertes Denken erzwingen (Sequential Thinking)

Die KI neigt dazu, voreilig Lösungen zu präsentieren, wenn sie den Überblick verliert.

• Lösung: Aktiviere den Sequential Thinking MCP Server.

• Nutzen: Dies zwingt die KI dazu, Schritt für Schritt logisch nachzudenken und verschiedene Lösungswege abzuwägen, bevor sie Code schreibt. Das reduziert logische Fehler im Gedächtnis.

5. Zugriff auf aktuelle Daten (Context 7 Plugin)

Oft entstehen Probleme, weil das interne Wissen der KI veraltet ist und sie versucht, Lücken durch „Raten“ zu füllen.

• Lösung: Installiere das Plugin Context 7.

• Nutzen: Damit kann die KI aktuelle Dokumentationen und Schnittstellen (APIs) in Echtzeit abrufen. Sie muss sich also nicht auf ihr (eventuell lückenhaftes) Gedächtnis verlassen, sondern liest die Fakten frisch nach.

Zusammenfassung für den Laien: Man löst das Problem, indem man der KI nicht zu viel auf einmal zumutet, ihr Gedächtnis ständig beobachtet und sie in kleinen, frischen Arbeitsschritten mit spezialisierten Helfer-Programmen arbeiten lässt.

===================

Installation von Context7

Befehl im Chat von Claude Desktop: Installiere https://github.com/upstash/context7 in Claude

Registrieren bei Context7.

json von Claude Desktop erstellen / anpassen

am besten den Inhalt der JSON von Claude neu erstellen lassen und bemerken, dass die JSON um die Einträge von Context7 ergänzt werden sollen:

{
„mcpServers“: {
„context7“: {
„type“: „http“,
„url“: „https://mcp.context7.com/mcp“,
„headers“: {
„CONTEXT7_API_KEY“: „DEIN-API-KEY-HIER“
}
}
}
}

Prüfen ob es geklappt hat

In Claude Desktop: Einstellungen → dort sollte unter „Developer“ oder „MCP“ der Server context7 als verbunden angezeigt werden.

Fehlerbehebung:

winget install astral-sh.uv

winget install OpenJS.NodeJS.LTS

Stell dir vor, du hättest einen kleinen Roboter, der für dich Hausaufgaben macht oder Texte schreibt. Am Anfang ist er noch ein bisschen tollpatschig. Aber anstatt ihm jedes Mal zu sagen, was er falsch gemacht hat, gibst du ihm eine Checkliste und sagst: „Übe so lange von allein weiter, bis du jeden Punkt auf der Liste perfekt schaffst!“

Genau das ist die „Loop-Methode“ (Schleifen-Methode). Das Video zeigt, wie man eine KI dazu bringt, sich selbst immer weiter zu verbessern, bis das Ergebnis genau so ist, wie du es willst [03:13].

Hier ist die Anleitung, wie das funktioniert – erklärt für dich Schritt für Schritt:

Teil 1: Die allgemeine Beschreibung (Wie der Loop funktioniert)

Man kann diesen Prozess in drei große Phasen unterteilen:

1. Die Anleitung (Der Skill): Du schreibst der KI eine erste Anleitung, was sie tun soll (z. B. „Schreibe eine Video-Beschreibung“).

2. Die Prüfung (Die Eval): Du erstellst Test-Beispiele und eine Checkliste mit Fragen, die man nur mit „Ja“ oder „Nein“ beantworten kann (z. B. „Sind Emojis drin?“, „Ist der Text länger als 10 Sätze?“) [03:30].

3. Der Trainer (Der Loop): Die KI lässt ihre Anleitung gegen die Test-Beispiele laufen. Wenn sie eine Regel bricht (z. B. doch ein Emoji benutzt), muss sie ihre eigene Anleitung umschreiben und es nochmal versuchen. Das macht sie so lange, bis sie 100 % der Punkte erreicht [08:14].

Teil 2: Ein konkretes Beispiel

Beispiel: Ein „Gaming-Tipp-Schreiber“ für YouTube. Du möchtest, dass die KI Tipps zu Spielen schreibt, aber sie soll keine Schimpfwörter benutzen, maximal 3 Tipps geben und am Ende immer schreiben: „Viel Spaß beim Zocken!“.

Schritt 1: Den Skill erstellen

Du sagst der KI, sie soll eine Datei namens gaming_skill.md anlegen, in der steht, wie man gute Tipps schreibt.

Schritt 2: Die Prüfung festlegen (Eval)

Du gibst der KI 5 verschiedene Spiele vor. Für jedes Spiel soll sie Tipps schreiben. Danach wird geprüft:

• Hat der Text weniger als 100 Wörter? (Ja/Nein)

• Sind es genau 3 Tipps? (Ja/Nein)

• Fehlen Schimpfwörter? (Ja/Nein)

• Ist der Satz „Viel Spaß beim Zocken!“ am Ende? (Ja/Nein)

Schritt 3: Den Loop starten

Die KI merkt vielleicht: „Oh, bei Minecraft habe ich 4 Tipps gegeben.“ Dann verbessert sie ihre Anleitung so lange, bis sie bei allen 5 Spielen immer genau 3 Tipps gibt [12:05].

Teil 3: Die Prompts (Die Befehle für die KI)

Hier sind die Befehle, die du nacheinander eingeben kannst (z. B. in Claude oder ChatGPT).

Wichtig: Wenn du mit Programmier-Code arbeitest, füge ich die Kommentare so ein, wie du es dir gewünscht hast.

Prompt 1: Den ersten Skill erstellen

„Erstelle mir einen Skill für einen [HIER THEMA EINSETZEN, z.B. Gaming-Tipp-Schreiber]. Schreibe die Anleitung in eine Datei namens skill.md. Die Anleitung soll erklären, wie man [DEIN ZIEL] erreicht.“

Prompt 2: Die Test-Datei (Eval) erstellen

„Erstelle eine Datei namens eval.json mit 5 Testfällen. Jeder Testfall braucht einen Beispiel-Input. Erstelle für jeden Testfall 5 Regeln (Assertions), die man nur mit JA oder NEIN beantworten kann. Die Regeln sollen prüfen, ob die Vorgaben aus der skill.md (z. B. keine Emojis, kurze Sätze) eingehalten werden.“

Prompt 3: Den Loop (die Selbstverbesserung) starten

„Starte jetzt einen Loop:

1. Führe den Skill aus der skill.md für alle Testfälle in der eval.json aus.

2. Prüfe für jeden Output die JA/NEIN-Regeln und berechne einen Score (Punkte).

3. Schreibe die Ergebnisse in eine loop-log.md.

4. Wenn der Score nicht perfekt ist: Analysiere die Fehler, verbessere die Anleitung in der skill.md und starte den Test von vorn.

5. Wiederhole das so lange, bis der Score perfekt ist, ohne mich zwischendurch zu fragen.“

 

Das Skript-Gerüst (für deine Unterlagen)

Wenn du der KI sagst, sie soll ein Log-Skript erstellen, kannst du ihr dieses Format vorgeben:

/* * BESCHREIBUNG: Protokoll-Struktur für die KI-Selbstverbesserung
 * AUTOR: MN
 * DATUM: 2026-03-26 / 20:22
 */
-- In der loop-log.md Datei werden folgende Dinge gespeichert:
-- 1. Durchlauf-Nummer (Iteration)
-- 2. Erreichter Score (z.B. 23 von 25 Punkten)
-- 3. Welche Regel wurde gebrochen? (z.B. "Emoji gefunden")
-- 4. Was wurde an der Anleitung geändert?

Was du beachten solltest (Tipps für 12-Jährige):

• Fachausdruck „Binäre Assertion“: Das klingt kompliziert, heißt aber nur: Eine Frage, die man nur mit „Wahr“ (Ja) oder „Falsch“ (Nein) beantworten kann [03:30].

• Geduld: Manchmal braucht die KI 2 oder 3 Versuche, bis sie ihre eigene Anleitung so umgebaut hat, dass sie keine Fehler mehr macht [12:08].

• Präzision: Je genauer deine Ja/Nein-Fragen sind, desto schneller lernt dein „Roboter“. Anstatt „Ist der Text gut?“ frage lieber „Hat der Text mehr als 50 Wörter?“.

Die Einführung von Claude 4.6 und Claude Code hat eine neue Ära der Zusammenarbeit zwischen KI-Agenten eingeläutet. Anstatt nur einen einzelnen Assistenten zu haben, kannst du nun ganze Teams (oft als „Swarms“ oder „Agent Teams“ bezeichnet) orchestrieren, die parallel arbeiten und miteinander kommunizieren.

1. Was sind Agent Teams / Swarms? (Für Anfänger)

Stell dir vor, du hast nicht nur einen Mitarbeiter, dem du eine Aufgabe gibst, sondern eine ganze Abteilung.

• Früher (Sub-Agents): Ein Chef-Agent hat Aufgaben an Unter-Agenten verteilt. Diese konnten aber nur dem Chef antworten, nicht untereinander reden.

• Heute (Agent Teams): Mehrere Agenten arbeiten gleichzeitig in ihren eigenen „Fenstern“. Sie teilen sich eine gemeinsame Aufgabenliste und können sich gegenseitig Nachrichten in eine Art „Posteingang“ (Inbox) schicken.

Der Vorteil: Sie können Probleme gemeinsam lösen, sich gegenseitig korrigieren (z. B. einer schreibt Code, einer testet, einer schreibt die Doku) und arbeiten deutlich schneller durch Parallelisierung.

2. Die Architektur (Für Experten)

Das System basiert auf drei Kernkomponenten in Claude Code:

1. Shared Task List: Alle Agenten greifen auf dieselbe Liste zu. Aufgaben können Abhängigkeiten („Blocker“) haben. Ein Agent beginnt erst, wenn seine Voraufgabe erledigt ist.

2. Inbox System: Agenten können Nachrichten an die inbox anderer Teammitglieder senden. Dies verhindert, dass Agenten auf Basis veralteter Annahmen arbeiten.

3. Parallel Execution: Mehrere Instanzen laufen gleichzeitig, was die Effizienz steigert, aber auch den Token-Verbrauch erhöht.

3. Einrichtung in deinem Workspace

Um Agent Teams nutzen zu können, musst du Claude Code installiert haben und sicherstellen, dass die Umgebungsvariablen richtig gesetzt sind.

Voraussetzungen:

Stelle sicher, dass in deiner settings.local.json (im .claude-Ordner deines Projekts) keine Telemetrie-Blocker aktiv sind, die die Team-Funktion stören könnten:

{
  "DISABLE_TELEMETRY": 0,
  "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": 0
}

Führe danach claude update aus, um auf der neuesten Version zu sein.

4. Praktische Umsetzung & Prompts

Du startest ein Team direkt über das Terminal in Claude Code. Hier sind Beispiele für verschiedene Szenarien:

Szenario A: SEO- & Content-Analyse (Mediterrane Rezepte)

Da du gerne pikant und ohne Zusatzstoffe kochst, hier ein Team-Prompt für deine Rezept-Website:

Prompt:

„Erstelle ein Agenten-Team, um meine Rezeptsammlung für den Thermomix TM7 zu analysieren.

• Agent 1 (SEO-Experte): Optimiere die Keywords für ‚pikante mediterrane Küche‘.

• Agent 2 (Gesundheits-Coach): Prüfe die Zutaten auf schädliche Zusatzstoffe und schlage natürliche Alternativen vor.

• Agent 3 (Struktur-Editor): Wandle die Texte in das Format für ‚Meine Kreationen‘ in Cookidoo um. Sie sollen ihre Ergebnisse abstimmen und einen gemeinsamen Redaktionsplan erstellen.“

Szenario B: IT / SQL-Entwicklung (Linked Server AS400)

Für deine Arbeit mit SQL Server 2019/2022 und DB2:

Prompt:

„Starte ein Team aus zwei Agenten, um eine komplexe Abfrage über einen LinkedServer zur AS400 zu optimieren.

• Agent 1 (T-SQL Spezialist): Analysiere die OpenQuery-Syntax auf Performance-Flaschenhälse.

• Agent 2 (DB2 Experte): Prüfe die Index-Nutzung auf der AS400 Seite. Agent 2 soll Agent 1 informieren, sobald die Remote-Tabellenstruktur validiert ist.“

 

5. Steuerung im Terminal

Wenn das Team läuft, kannst du zwischen den Agenten wechseln:

• Shift + Pfeiltaste Hoch/Runter: Wechselt die Ansicht zwischen den aktiven Agenten (z. B. vom „Team Lead“ zum „Developer“).

• Nachricht senden: Du kannst während des Prozesses direkt in das Fenster eines Agenten schreiben, um manuell einzugreifen.

• Effort Level: Du kannst mit den Pfeiltasten den „Effort“ (Aufwand) für Opus 4.6 einstellen:

  • Low: Einfache Aufgaben, spart Token.

  • Medium: Standard für agentische Aufgaben.

  • High: Komplexe logische Probleme (kostet mehr).

Zusammenfassung: „Das Wichtigste in Kürze“ (SEO-optimiert)

• Konzept: Agent Teams sind spezialisierte KI-Einheiten, die in Claude Code parallel an einem Ziel arbeiten.

• Kommunikation: Über ein internes Postfach-System tauschen sie Infos aus, um Fehler zu vermeiden.

• Vorteil: Massive Zeitersparnis bei komplexen Projekten (Programmierung, Content-Erstellung).

• Kosten: Beachte, dass 3 Agenten gleichzeitig auch den 3-fachen Token-Verbrauch bedeuten.

Dieser AI-Marketing-Skill ist ein leistungsstarkes System für Claude Code (das neue Terminal-Tool von Anthropic). Es verwandelt Claude in eine automatisierte Marketing-Agentur, die Webseiten analysiert, SEO-Audits durchführt und fertige Berichte erstellt.

Hier ist die lückenlose Anleitung, wie du diesen Skill aufbaust und nutzt.

Voraussetzungen

Bevor du startest, benötigst du diese Grundlagen:

1. Visual Studio Code (VS Code): Dein Editor.

2. Claude Code Erweiterung: Suche in den VS Code Extensions nach „Claude Code“ (von Anthropic) und installiere sie.

3. Claude Pro Abonnement: Da Claude Code über die API oder das Pro-Modell läuft, ist ein aktiver Account erforderlich.

4. Python: Für die PDF-Berichtserstellung (optional, aber empfohlen).

Schritt-für-Schritt Installation

1. Claude Code einrichten

Öffne VS Code und logge dich in der Claude Code Erweiterung ein. Du siehst dann ein „Spark“-Icon (ein kleiner Stern) oben rechts oder in der Seitenleiste. Klicke darauf, um das Claude-Terminal zu öffnen.

2. Den Marketing-Skill installieren

Der Skill von Zubair Trabzada wird über ein GitHub-Repository bereitgestellt. Du kannst ihn mit einem einzigen Befehl direkt in deinem Terminal installieren:

Kopiere diesen Befehl und füge ihn in dein VS Code Terminal (oder ein normales Terminal im Projektordner) ein:

curl -fsSL https://raw.githubusercontent.com/zubair-trabzada/ai-marketing-claude/main/install.sh | bash

Was passiert hier? Dieses Skript lädt die notwendigen Prompts und Logiken herunter und registriert sie als „Slash-Commands“ (Befehle, die mit / beginnen) in deiner Claude Code Umgebung.

3. PDF-Support aktivieren (Optional)

Damit Claude professionelle PDF-Berichte für Kunden erstellen kann, musst du eine Python-Bibliothek installieren:

pip install reportlab

Detaillierte Funktionsweise & Logik (Der Aufbau)

Der Skill basiert auf einer Multi-Agenten-Architektur. Wenn du einen Befehl ausführst, passiert im Hintergrund folgendes:

1. Parallele Agenten: Der Befehl /market audit startet 5 spezialisierte KI-Agenten gleichzeitig.

   • Agent 1 (Content): Analysiert Texte und Botschaften.

   • Agent 2 (Conversion): Prüft Call-to-Actions und Nutzerführung.

   • Agent 3 (SEO): Scant Metadaten und Durchsuchbarkeit.

   • Agent 4 (Wettbewerb): Vergleicht die Seite mit ähnlichen Anbietern.

   • Agent 5 (Brand & Trust): Bewertet die Vertrauenswürdigkeit und das Branding.

2. Datenextraktion: Claude nutzt seine Browser-Funktion, um die angegebene URL live zu besuchen und den Quellcode sowie den sichtbaren Text zu lesen.

3. Synthese: Die Ergebnisse der 5 Agenten werden zusammengeführt, gewichtet (Scoring-System von 0-100) und in eine strukturierte Markdown-Datei (MARKETING-AUDIT.md) geschrieben.

4. Output: Am Ende wird auf Wunsch die Python-Logik (reportlab) genutzt, um die Markdown-Daten in ein schönes PDF-Layout zu konvertieren.

So nutzt du den Skill

Sobald die Installation fertig ist, kannst du im Claude-Fenster einfach folgende Befehle tippen:

Beispiel für die Anwendung:

Gib einfach ein: /market audit https://deine-webseite.de

Claude beginnt sofort mit der Arbeit, zeigt dir den Fortschritt der 5 Agenten und speichert den Bericht in deinem aktuellen Ordner.