---
name: learnfromsocials
description: Holt Social-Media-Links aus der Inbox, laedt Content runter (Video, Bilder, Slideshows), transkribiert und analysiert alles.
---

# Social Media Content analysieren

Verarbeite Links aus der Inbox-Datei. Unterstuetzt alle Content-Typen: Videos, Slideshows, Bilder, Text-Posts.

## Vorbedingung

Pruefe ob die noetigen CLI-Tools verfuegbar sind:
```bash
which yt-dlp && which ffmpeg && which gallery-dl && Code/reels-analyzer/venv/bin/whisper --help 2>&1 | head -1
```
Falls etwas fehlt: Robin darauf hinweisen und Setup-Anleitung zeigen:
```bash
brew install yt-dlp ffmpeg gallery-dl
cd Code/reels-analyzer && python3 -m venv venv && source venv/bin/activate && pip install openai-whisper
```

**Wichtig:** Whisper laeuft in einer venv unter `Code/reels-analyzer/venv/`. Immer den vollen Pfad nutzen: `Code/reels-analyzer/venv/bin/whisper`

## Schritt 1: Inbox lesen

Lies die Datei `Code/reels-analyzer/inbox.txt` (relativ zum Projekt-Root).

- Eine URL pro Zeile
- Leere Zeilen und Kommentare (mit #) ignorieren
- Wenn die Inbox leer ist oder nicht existiert: Robin informieren und abbrechen

## Schritt 2: Content verarbeiten

Fuer JEDEN Link in der Inbox den Content-Typ ermitteln und entsprechend verarbeiten.

### 2a. Download versuchen (yt-dlp)

```bash
yt-dlp -o "Code/reels-analyzer/media/%(id)s.%(ext)s" --format "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best" --merge-output-format mp4 --write-thumbnail "URL"
```

`--write-thumbnail` speichert das Vorschaubild mit (nuetzlich bei reinen Bild-Posts).

**Wenn yt-dlp fehlschlaegt oder "No video formats found"** (Bild-Carousel, Photo-Post, nicht unterstuetzte Plattform):

**Fallback-Kette:**

0. **Instagram Bild-Carousels** (yt-dlp meldet "No video formats found" aber erkennt Items): `gallery-dl` nutzen, das Bilder von Instagram herunterladen kann:
   ```bash
   gallery-dl --cookies-from-browser opera -d "Code/reels-analyzer/media/" "URL"
   ```
   Voraussetzung: Opera GX mit Instagram-Login. Symlinks muessen existieren:
   - `~/Library/Application Support/com.operasoftware.Opera/Cookies` → `~/Library/Application Support/com.operasoftware.OperaGX/Default/Cookies`
   - `~/Library/Application Support/com.operasoftware.Opera/Local State` → `~/Library/Application Support/com.operasoftware.OperaGX/Default/Local State`

   gallery-dl erstellt Unterordner nach Plattform/User — nach dem Download Bilder in `media/` verschieben und Unterordner entfernen.

1. **TikTok Photo-Posts** (`/photo/` in URL): yt-dlp unterstuetzt diese nicht. Stattdessen:
   ```bash
   # HTML laden mit Mobile User-Agent
   curl -sL -A "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X)" "URL" -o /tmp/tiktok_page.html
   ```
   Dann mit Python die Bild-URLs und Beschreibung extrahieren:
   ```python
   import re
   with open('/tmp/tiktok_page.html', 'r') as f: html = f.read()
   # Beschreibung
   descs = re.findall(r'"desc":"([^"]*)"', html)
   # Slide-Bilder (unique by hash)
   urls = re.findall(r'"imageURL":\{"urlList":\["([^"]+)"', html)
   # URLs entescapen: url.replace('\\u002F', '/')
   # Slides mit curl herunterladen
   ```
   Jede Slide als einzelnes JPG herunterladen und mit Claude Vision lesen.

2. **Andere Plattformen**: WebFetch um die Seite zu lesen und den Text/Inhalt zu extrahieren.

3. **Wenn WebFetch auch fehlschlaegt**: Wayback Machine via curl (NICHT WebFetch — das blockt archive.org):
   ```bash
   curl -sL "https://web.archive.org/web/URL" -o /tmp/wayback_page.html
   ```

### 2b. Content-Typ erkennen

Nach dem Download pruefen was vorliegt:

```bash
ls Code/reels-analyzer/media/VIDEO_ID.*
```

| Dateien vorhanden | Content-Typ | Naechster Schritt |
|---|---|---|
| `.mp4` vorhanden | Video | → Audio + Frames extrahieren |
| Nur `.webp`/`.jpg`/`.png` | Einzelbild/Infografik | → Direkt mit Claude Vision lesen |
| Gar nichts (yt-dlp fehlgeschlagen) | Text-Post oder nicht unterstuetzt | → WebFetch Fallback |

### 2c. Video verarbeiten (wenn .mp4 vorhanden)

**Audio extrahieren und transkribieren:**
```bash
ffmpeg -i "Code/reels-analyzer/media/VIDEO_ID.mp4" -vn -ar 16000 -ac 1 -y "Code/reels-analyzer/media/VIDEO_ID.wav"
Code/reels-analyzer/venv/bin/whisper "Code/reels-analyzer/media/VIDEO_ID.wav" --model base --output_format txt --output_dir "Code/reels-analyzer/media/"
```

Transkript lesen. Wenn das Transkript leer oder nur Musik ist (sehr kurz, kein sinnvoller Text), dann ist das Video visuell — weiter mit Frames.

**Frames extrahieren (IMMER bei Videos, auch wenn Transkript vorhanden):**
```bash
# 1 Frame pro Sekunde, max 30 Frames
ffmpeg -i "Code/reels-analyzer/media/VIDEO_ID.mp4" -vf "fps=1" -frames:v 30 -y "Code/reels-analyzer/media/VIDEO_ID_frame_%03d.jpg"
```

Dann die Frames mit dem Read-Tool anschauen (Claude Vision). Besonders wichtig bei:
- Slideshows/Carousels (jeder Frame = eine Slide)
- Code-Snippets die im Video gezeigt werden
- Diagramme, Infografiken, UI-Screenshots
- Text-Overlays die nicht gesprochen werden

### 2d. Bild verarbeiten (wenn nur Bild vorhanden)

Bild direkt mit dem Read-Tool oeffnen (Claude Vision). Typische Faelle:
- Infografik mit Text → Text extrahieren und analysieren
- Screenshot → Inhalt beschreiben
- Meme/Grafik → Kontext und Aussage erfassen

### 2e. WebFetch Fallback (wenn yt-dlp fehlschlaegt)

```
WebFetch URL
```

Seiteninhalt lesen und den relevanten Post-Text extrahieren. Funktioniert fuer:
- Twitter/X Posts
- Threads
- Blog-Artikel die als Link geteilt werden
- Jede andere Webseite

### 2f. Aufraeumen

Loesche Video- und Audio-Dateien (Speicherplatz). Behalte:
- `.txt` Transkripte
- Einen repraesentativen Frame (der erste oder informativste) als `.jpg`

```bash
rm -f Code/reels-analyzer/media/VIDEO_ID.mp4 Code/reels-analyzer/media/VIDEO_ID.wav
# Frames bis auf einen loeschen
ls Code/reels-analyzer/media/VIDEO_ID_frame_*.jpg 2>/dev/null | tail -n +2 | xargs rm -f 2>/dev/null
```

## Schritt 3: Analyse

Nachdem ALLE Inhalte verarbeitet sind, analysiere jeden einzeln.

Fuer jeden Content:
1. **Zusammenfassung:** Worum geht es im Detail?
2. **Key Takeaways:** Die wichtigsten Punkte als Liste
3. **Webdev-Relevanz:** Technologien, Tools, Techniken die erwaehnt oder gezeigt werden
4. **Einordnung:** Ist der Inhalt korrekt und aktuell? Gibt es Einschraenkungen oder Gegenargumente?
5. **Actionable:** Was kann Robin konkret daraus mitnehmen?

Bei visuellen Inhalten (Slideshows, Infografiken, Code-Screenshots) zusaetzlich:
- **Gezeigter Code:** Wenn Code-Snippets sichtbar sind, diese extrahieren und erklaeren
- **Visuelles:** Diagramme, Architekturen, UI-Patterns beschreiben

## Schritt 4: Archivieren in Ordnerstruktur

Für JEDEN verarbeiteten Link einen beschreibend benannten Ordner unter `Projekt/reels-archive/` erstellen:

```bash
mkdir -p "Projekt/reels-archive/react-infinite-scroll-2026"
# Ordnername: Thema + Key-Konzepte, nicht Post-IDs!
```

**Struktur im Ordner:**
```
react-infinite-scroll-2026/
├── summary.md              # Vollständige Zusammenfassung
├── slide_001.jpg          # Bilder/Screenshots/Slides
├── slide_002.jpg
├── frame_001.jpg          # Repr. Frame bei Videos
└── transcript.txt         # Optional: Audio-Transkript
```

**Naming-Konventionen für Dateien:**
- `slide_001.jpg`, `slide_002.jpg` — Carousel-Slides, Screenshots
- `frame_001.jpg` — Repräsentative Frame bei Videos
- `transcript.txt` — Falls Video → Audio-Transkript
- Keine Unterordner wie `media/` oder `images/` — alles flach

### summary.md Format

```markdown
# {TITEL}

**Quelle:** {PLATFORM} @{ACCOUNT}  
**URL:** {ORIGINAL_URL}  
**Verarbeitet:** {DATUM}  
**Content-Typ:** {Video|Reel|Carousel|Bild|Text}  

## Zusammenfassung
{Kurze Beschreibung worum es geht}

## Key Takeaways
- Punkt 1
- Punkt 2
- Punkt 3

## Webdev-Relevanz
{Hoch|Mittel|Niedrig} — {Begründung}

## Details
{Weitere Infos: Code-Snippets, spezifische Tools, Author, Learnings}

## Archiv
- Images: {Anzahl} Files
- Transcript: {ja/nein}
```

**Beispiel:**
```markdown
# React Infinite Scroll Advanced

**Quelle:** Instagram @frontend_in.depth  
**URL:** https://www.instagram.com/p/DWnT9_aAjqQ/  
**Verarbeitet:** 2026-04-05  
**Content-Typ:** Carousel (13 Slides)

## Zusammenfassung
Umfassende Anleitung zur korrekten Implementierung von Infinite Scroll in React 2026. Behandelt: IntersectionObserver statt onScroll, useInfiniteQuery (TanStack), Cursor-basierte Pagination, DOM-Virtualization, Memory-Leak-Prevention.

## Key Takeaways
- IntersectionObserver verwenden statt onScroll Events
- TanStack Query useInfiniteQuery als Standard (Caching, Dedup)
- Cursor-basierte Pagination nicht Offset (O(1) statt O(n))
- Virtualization Pflicht ab 200+ Items (TanStack Virtual)
- Skeleton Loading, nicht Spinner

## Webdev-Relevanz
Sehr Hoch — Production-Standard für React/Feed-Features

## Details
Stack 2026: IntersectionObserver + useInfiniteQuery + Cursor + TanStack Virtual

Archiv: 13 Slides, keine Transkripte nötig
```

## Schritt 5: Inbox aufraeumen

Verschiebe verarbeitete Links aus `inbox.txt` in `Code/reels-analyzer/processed.txt` (mit Datum):
```
# 2026-04-05
https://www.instagram.com/p/DWDzvtCDZVH/
https://www.instagram.com/reels/DWZdw5SgRR6/
```

Leere die inbox.txt danach (nur die verarbeiteten Links entfernen).

## Schritt 6: Vertiefende Recherche (optional aber empfohlen)

Nachdem der Inhalt analysiert ist, vor dem Tool-File schreiben: Prüfen ob eine kurze Recherche den Inhalt signifikant bereichert.

**Recherche durchführen wenn:**
- Das Video nur an der Oberfläche kratzt (30-60s TikTok über ein komplexes Tool)
- GitHub-Link sichtbar war → README lesen für Details die im Video fehlten
- Wichtige Fragen offen sind: Aktuelle Version? Breaking Changes? Lizenz? Alternativen?
- Das Tool noch unbekannt ist und der Kontext fehlt

**Recherche überspringen wenn:**
- Der Content bereits erschöpfend ist (langer Carousel, detaillierte Slides)
- Das Tool schon bekannt ist und nur ein neues Pattern gezeigt wurde
- Es sich um ein Thema handelt, nicht um ein konkretes Tool

**Recherche-Vorgehen:**
```
1. WebFetch auf GitHub-Seite des Tools → README, Stars, letzter Commit, Issues
2. Optional: WebSearch "tool-name best practices 2026" oder "tool-name vs alternative"
3. Erkenntnisse direkt ins Tool-File einarbeiten — nicht separat dokumentieren
```

## Schritt 7: Tools extrahieren & Learnings einarbeiten

**Alles was Robin schickt ist wertvoll** — ausführlich analysieren und praktische Tools extrahieren.

### A. Tool-Datei oder Theme-Datei anlegen

Zuerst entscheiden: Ist der Inhalt ein **konkretes Tool** oder ein **spezifisches Thema**?

| Content-Typ | Dateiname | Beispiel |
|---|---|---|
| Konkretes Tool/Library | `{tool-name}.md` | `pretext-dom-free-text-animations.md` |
| Spezifisches Thema | `{thema-spezifisch}.md` | `framer-spring-physics-animations.md` |
| Update zu bestehendem Tool | Bestehende Datei updaten | `framer-motion-animations.md` erweitern |
| Ergänzung zu bestehender Rule | Rule direkt updaten | Nichts in `tools/` anlegen |

**Was ist "spezifisch genug"?**
- `framer-spring-physics-animations.md` ✅ — konkretes Thema mit klarem Trigger
- `css-scroll-driven-animations.md` ✅ — neue Browser-API, klarer Anwendungsfall
- `ux-animations.md` ❌ — zu breit, zu viele Links würden da reinlaufen
- `performance-tips.md` ❌ — kein klarer Trigger, wann würde man das lesen?

**Faustregel:** Wenn du dir vorstellst, du suchst das File weil du gerade ein Feature baust — wäre der Name spezifisch genug um es zu finden?

**Format der Tool-Datei:**
```markdown
# {TOOL-NAME oder SPEZIFISCHES THEMA}

**Quelle:** {Platform} @{Account}
**Archiv:** `Projekt/reels-archive/{ordnername}/`

## Problem / Kontext
{Worum geht es? Was war das Problem?}

## Lösung / Pattern
{Konkrete Lösung, Code-Snippets, Checklisten}

## Wann einsetzen
{Klare Trigger — wann ist dieses Tool/Pattern relevant?}

## Wann NICHT
{Gegenbeispiele, Einschränkungen}

## Weiterführend (optional)
→ Wenn das Thema bereits in einer Rule abgedeckt ist: Verweis drauf
```

### B. Index-Zeile in `rules/tools.md` ergänzen

Nach dem Anlegen der Tool-Datei eine neue Zeile in die passende Kategorie in `.claude/rules/tools.md` eintragen:

```
| {Tool-Name} | {Wann lesen — kurzer Trigger} | `.claude/tools/{dateiname}.md` |
```

Wenn keine passende Kategorie existiert: neue Kategorie anlegen.

### C. Vertiefte Einarbeitung je nach Learning-Typ

| Learning-Typ | Aktion |
|---|---|
| Neues spezifisches Tool/Pattern | `.claude/tools/` Datei anlegen + Index-Zeile |
| Ergänzung zu bestehendem Tool | Bestehende Tool-Datei updaten, kein neuer Eintrag |
| Ergänzung zu bestehender Rule | Rule direkt updaten, kein `tools/`-Eintrag |
| Security-Wissen | `security.md` updaten + ggf. `tools/` Datei |
| Workflow-Änderung | `base.md` oder bestehende Rule updaten |

## Projektstruktur

```
Projekt/
├── notizen.md
├── reels-archive/          # ← Archive aller verarbeiteten Links
│   ├── animation-skill-file-emilkowalski/
│   │   ├── summary.md
│   │   ├── frame_001.jpg
│   │   └── transcript.txt
│   ├── react-infinite-scroll-intersectionobserver-2026/
│   │   ├── summary.md
│   │   ├── slide_001.jpg
│   │   ├── slide_002.jpg
│   │   └── ...
│   ├── github-repos-coolify-pocketbase-trigger/
│   │   └── summary.md
│   └── ...
└── assets/
```

**Benennungskonvention für Ordner:**
Format: `{thema}-{key-concepts}` (alles lowercase, mit Bindestrich)

Beispiele:
- `animation-skill-file-emilkowalski`
- `react-infinite-scroll-intersectionobserver-2026`
- `framer-premium-website-look-backdrop-blur`
- `security-tools-kali-mcp-tenzai-pentera`

**Ablauf beim Verarbeiten:**
1. Link downloaden → Dateien landen in `Code/reels-analyzer/media/`
2. Analysieren + summary.md schreiben
3. Neuen Ordner mit beschreibendem Namen erstellen
4. Dateien in Ordner verschieben (keine Unterordner!)
5. summary.md in Ordner-Root speichern
6. Link in inbox.txt löschen + processed.txt eintragen
7. `Code/reels-analyzer/media/` aufräumen

---

## Schritt 8: Zusammenfassung

Gib Robin eine kompakte Uebersicht:
1. Tabelle aller analysierten Inhalte mit Relevanz-Einschaetzung
2. Was wurde wo eingearbeitet (Rule-Updates, neue Memories)
3. Was war nicht relevant genug fuers Blueprint

## Regeln

- Alle Operationen laufen lokal — keine externen APIs ausser yt-dlp-Downloads und WebFetch
- Videos und Audio nach der Verarbeitung loeschen (Speicherplatz)
- Transkripte und ein repraesentativer Frame bleiben in `media/` als Referenz
- Bei Download-Fehlern: WebFetch als Fallback versuchen bevor der Link uebersprungen wird
- Whisper-Modell `base` als Default (schnell genug fuer kurze Videos auf CPU)
- Frames auf max 30 begrenzen (Token-Verbrauch bei Claude Vision)

$ARGUMENTS