Communitygithub.com

Claude Eye

Analysiere eine Bildschirmaufnahme einer Web-/UI-Animation Bild für Bild, um Timing-Fehler zu finden, wie z. B. asynchrone Ein- und Ausblendungen, zeitlich falsch abgestimmte Übergänge, Flackern oder Ruckeln. Nutzt ffmpeg und Claudes eigene Bilderkennung.

Was ist Claude Eye?

Claude Eye ist ein Skill für Claude Code (und ähnliche KI-Agenten), der eine Bildschirmaufnahme (Video- oder GIF-Datei) einer Web- oder UI-Animation in einzelne Frames zerlegt und diese dann mithilfe von ffmpeg und der integrierten Bildverständnisfähigkeit (Vision) von Claude analysiert. Der Skill erstellt einen detaillierten, mit Zeitstempeln versehenen Bericht über den zeitlichen Ablauf aller animierten Elemente (z. B. Titel, Schaltflächen, Untertitel) und identifiziert Desynchronisationen (Desyncs), bei denen einige Elemente bereits sichtbar sind, während andere noch ein- oder ausgeblendet werden. Der Workflow umfasst das Extrahieren von Frames (VIA ein Node.js-Skript), das manuelle Betrachten und Dokumentieren jedes Frames (wobei konsistente Selektornamen verwendet werden müssen) und das Erstellen eines zusammenfassenden Berichts (report.md) mit einer Tabelle des Opazitätsverlaufs und Empfehlungen. Da der Skill auf Claudes eigenem Vision-Modul basiert, ist kein separater API-Key erforderlich. Er eignet sich besonders gut für die Fehlersuche bei CSS/JS-Animationen (z. B. bei Übergängen, Hero-Bereichen oder Ladeanimationen), bei denen Timing-Fehler im Bereich von 100–300 ms liegen und für das menschliche Auge zu schnell sind, aber in einer Frame-Tabelle leicht erkannt werden können.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/AbbasMalikzada/claude-eye-skill/tree/HEAD/claude-eye

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Claude Eye: Bild-für-Bild-Animationen analysieren

Du kannst kein Video ansehen, aber du kannst Bilder lesen. Dieser Skill verwandelt ein Video in eine Reihe von mit Zeitstempeln versehenen Frames, lässt dich jeden Frame betrachten und notieren, was jedes animierte Element tut, und erstellt dann aus diesen Beobachtungen eine Zeitleiste, die genau zeigt, wann Dinge aus dem Takt geraten. Timing-Fehler in CSS/JS-Animationen liegen normalerweise 100–300 ms daneben – zu schnell, um sie mit dem Auge zu sehen, aber leicht in einer Frame-Tabelle erkennbar.

Die Skripte befinden sich neben dieser Datei in scripts/. Sie benötigen nur Node 18+ und ffmpeg/ffprobe, kein npm install. <skill> steht unten für das Verzeichnis dieses Skills.

1. Voraussetzungen prüfen

Führe ffmpeg -version aus. Fehlt es, informiere den Benutzer und gib den Installationsbefehl für sein Betriebssystem (Windows: winget install Gyan.FFmpeg oder choco install ffmpeg; macOS: brew install ffmpeg; Linux: sudo apt install ffmpeg). Danach wird ein neues Terminal benötigt. Installiere es nicht selbst ohne Nachfrage.

2. Frames extrahieren

node <skill>/scripts/extract_frames.mjs <video> --fps 5 --out ./claude-eye-output [--start S] [--end S] [--width 960]

Dies erzeugt frames/frame_NNNN.png plus eine manifest.json, die jede Frame-Nummer mit ihrem Zeitstempel verknüpft. Verwende immer die Zeitstempel aus dem Manifest, berechne sie niemals im Kopf.

Plane deine Bild-Lesevorgänge budgetgerecht. Jeder gelesene Frame kostet Kontext, also strebe etwa 40 Frames oder weniger pro Durchlauf an:

  • Kurzer Clip (unter ~8 s): 5 fps über die gesamte Länge sind in Ordnung.
  • Längerer Clip, oder du weißt nicht, wo das Problem liegt: Mache zuerst einen groben Durchlauf (--fps 1 oder 2 über das gesamte Video), um zu finden, wo sich etwas bewegt. Extrahiere dann nur dieses Zeitfenster mit höherer fps (--start/--end, --fps 10-15) in ein separates --out-Verzeichnis. Berichte den feinen Durchlauf.
  • Wenn der Benutzer einen Moment nennt („etwa bei 3 Sekunden“, „wenn der Titel erscheint“), gehe direkt zu diesem Fenster.

Die Standardbreite von 960 px reicht aus, um Opazität und Position zu beurteilen. Verwende eine größere --width nur, wenn die Elemente sehr klein sind.

3. Frames betrachten und Beobachtungen notieren

Lies die Frames der Reihe nach mit dem Lese-Werkzeug. Notiere für jeden Frame jedes sichtbare Text-/UI-Element, das animiert wird oder animiert werden könnte: Titel, Untertitel, Schaltflächen, Bilder, Highlight-Spannen, Overlays usw.

Behalte konsistente Selektornamen über alle Frames hinweg bei: Wähle beim ersten Anblick eines Elements einen deskriptiven kebab-case-Namen (hero-title, subtitle, cta-button) und verwende genau diesen Namen in jedem späteren Frame. Die Zeitleiste verbindet Frames anhand des Namens, daher würden hero-title in einem Frame und title im nächsten als zwei verschiedene Elemente behandelt, und die Analyse wird unbrauchbar. Nimm ein Element mit dem Zustand 0% auf, sobald es vorhanden ist oder bekannt ist, dass es existiert. Dadurch werden die „versteckt → wird eingeblendet“-Punkte sichtbar.

Schätze für jedes Element:

  • opacity_percent (0–100). Beurteile es im Vergleich zum Hintergrund und zur vollständig sichtbaren Darstellung des Elements in späteren Frames. Zähle auch partielle Einblendungen: Ein Clip-Pfad oder Masken-Wipe, der zu 40% sichtbar ist, zählt als 40.
  • state: einer von hidden (≤10%), transitioning-in (steigend), visible (≥90%), transitioning-out (fallend). Vergleiche mit benachbarten Frames, um „rein“ von „raus“ zu unterscheiden.
  • Optional: has_gradient, has_blur, und notes für Dinge wie Bewegung ("translateY ~20px über der Endposition"), Skalierung, Unschärfegrad oder Farbänderung. Bewegung und Skalierung sind genauso wichtig wie Opazität, notiere sie daher in notes, wenn du sie siehst.

Schreibe alles in <out>/frames.json:

[
  {
    "frame": 1,
    "elements": [
      { "selector": "hero-title", "opacity_percent": 0, "state": "hidden" },
      { "selector": "subtitle", "opacity_percent": 0, "state": "hidden" }
    ],
    "overall_state": "pre-animation",
    "observation": "Leerer Hero-Bereich; noch nichts gerendert."
  }
]

frame muss mit den Frame-Nummern im Manifest übereinstimmen. Zeitstempel werden aus dem Manifest eingefügt. Schreibe die Datei bei langen Durchläufen in Teilen, während du arbeitest, anstatt 40 Frames im Speicher zu behalten.

Die Opazität aus einem komprimierten Video ist nur ein Näherungswert. Ein Unterschied von ±10% zwischen Frames ist Rauschen; Muster über mehrere Frames hinweg sind das Signal.

4. Bericht erstellen

node <skill>/scripts/build_report.mjs ./claude-eye-output --context "was die Animation tun soll"

Dies erzeugt report.md (Zusammenfassung, Opazität-Zeitleistetabelle, Timing pro Element, Übergangspunkte, Desync-Ereignisse, Beobachtungen) und analysis.json. Ein Desync ist ein Frame, in dem einige Elemente vollständig sichtbar sind, während andere noch übergehen, mit mehr als 40 Punkten Opazitätsunterschied zwischen ihnen. Verwende --spread N, um dies strenger oder lockerer zu gestalten.

5. Interpretieren: Hier liegt dein Mehrwert

Das Skript findet wann Dinge passieren. Deine Aufgabe ist es zu sagen, warum und was geändert werden muss:

  1. Ersetze den Abschnitt <!-- RECOMMENDATIONS --> in report.md durch spezifische Ergebnisse. Lies die Tabelle des Element-Timings: Zum Beispiel „subtitle beginnt 200 ms nach hero-title und erreicht 400 ms später volle Opazität, was auf eine längere Dauer plus eine Verzögerung hindeutet.“ Rechne Frame-Lücken mit dem Frame-Abstand (1/fps) in Millisekunden um.
  2. Wenn der Quellcode des Benutzers verfügbar ist, finde das CSS/JS für diese Elemente (transition, animation, @keyframes, transition-delay, Framermotion/GSAP-Konfigurationen) und verweise auf die genauen Zeilen, die das beobachtete Timing erklären. Schlage die konkrete Korrektur vor.
  3. Erwähne deine Timing-Genauigkeit (±1 Frame = ±1/fps s). Wenn eine Schlussfolgerung von einer Lücke abhängt, die kleiner als ein Frame ist, extrahiere dieses Fenster mit einer höheren fps erneut, bevor du sie behauptest.

Gib dem Benutzer dann eine kurze Zusammenfassung im Chat: was animiert wird, die wichtigsten Timings, jeden Desync mit seinem Zeitstempel und der wahrscheinlichen Ursache sowie die Korrektur. Füge den Pfad zu report.md bei.

Nicht nur Opazität

Die Berichtspipeline ist auf Opazität/Sichtbarkeit ausgelegt, aber derselbe Ansatz des Frame-Lesens funktioniert für andere Fragen, wie Layout-Verschiebungen, ein hüpfendes Element, Flickern (ein Frame mit falschem Zustand), einen Loader, der sich dreht, wenn er nicht sollte, oder ein Easing, das linear wirkt. Extrahiere auch dafür Frames und lies sie. Du kannst build_report.mjs überspringen und direkt mit auf das Manifest bezogenen Zeitstempeln antworten.

Verwandte Skills