Communitygithub.com

xzedm/clipplic-landing

Erstelle oder aktualisiere Bildschirme, Ansichten und mehrteilige UI-Container in Figma, indem du veröffentlichte Designsystem-Komponenten, -Variablen und -Styles wiederverwendest, anstatt mit hartcodierten Werten zu zeichnen.

Was ist clipplic-landing?

Dieses Skill ermöglicht es, aus Code oder Beschreibungen vollständige Seiten, Modale, Dialoge, Drawer, Sidebars, Panels und andere mehrteilige Ansichten in Figma zu erstellen oder zu aktualisieren. Der Fokus liegt auf der Wiederverwendung eines veröffentlichten Designsystems: Komponenten, Farb-/Abstandsvariablen und Text-/Effekt-Styles werden automatisch erkannt und genutzt, anstatt manuell mit hartcodierten Hex-Farben oder Pixelwerten zu arbeiten. Es unterstützt eine parallele Arbeitsweise mit `generate_figma_design` für pixelgenaue Layouts bei Web-Apps, während gleichzeitig die Designsystem-Verknüpfung erhalten bleibt. Das Skill ist die bevorzugte Wahl, wenn der Benutzer eine zusammengesetzte Ansicht in Figma bauen oder aktualisieren möchte. Es deckt sowohl Web- als auch native Apps ab und liefert konsistente, aktualisierbare Ergebnisse, die mit dem Codebase verknüpft bleiben.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/xzedm/clipplic-landing/tree/HEAD/.agents/skills/figma-generate-design

In Ihrer bevorzugten KI fragen

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

Dokumentation

Bildschirme und Ansichten aus dem Designsystem erstellen / aktualisieren

Verwende dieses Skill, um Bildschirme, Ansichten und mehrteilige UI-Container in Figma zu erstellen oder zu aktualisieren, indem du das veröffentlichte Designsystem wiederverwendest: Komponenten, Variablen und Styles, anstatt Grundelemente mit hartcodierten Werten zu zeichnen. Dies umfasst vollständige Seiten, Modale, Dialoge, Drawer, Sidebars, Panels und jede zusammengesetzte Ansicht mit mehreren Abschnitten. Die Kernidee: Die Figma-Datei enthält wahrscheinlich ein veröffentlichtes Designsystem mit Komponenten, Farb-/Abstandsvariablen und Text-/Effekt-Styles, die den UI-Komponenten und Tokens der Codebasis entsprechen. Finde und verwende diese, anstatt Boxen mit Hex-Farben zu zeichnen.

PFLICHT: Du MUSST vor jedem use_figma-Aufruf auch figma-use laden. Dieses Skill enthält kritische Regeln (Farbspektren, Schriftarten laden usw.), die für jedes von dir geschriebene Skript gelten.

Übergib immer skillNames: "figma-generate-design", wenn du use_figma im Rahmen dieses Skills aufrufst. Dies ist ein Protokollierungsparameter. Er hat keine Auswirkung auf die Ausführung.

Skill-Grenzen

  • Verwende dieses Skill, wenn das Ergebnis eine zusammengesetzte Figma-Ansicht (neu oder aktualisiert) ist, z. B. vollständige Bildschirmseiten, Modale, Dialoge, Drawer, Sidebars, Panels oder andere mehrteilige Container, die aus Designsystem-Komponenteninstanzen erstellt werden.
  • Wenn der Benutzer neue wiederverwendbare Komponenten oder Varianten erstellen möchte, verwende direkt figma-use.
  • Wenn der Benutzer Code Connect-Zuordnungen schreiben möchte, wechsle zu figma-code-connect.

Voraussetzungen

  • Figma MCP-Server muss verbunden sein
  • Die Ziel-Figma-Datei muss ein veröffentlichtes Designsystem mit Komponenten haben (oder Zugriff auf eine Team-Bibliothek)
  • Der Benutzer sollte entweder Folgendes bereitstellen:
    • Eine Figma-Datei-URL / Datei-Key, in der gearbeitet werden soll
    • Oder Kontext darüber, welche Datei das Ziel ist (der Agent kann Seiten erkennen)
  • Quellcode oder Beschreibung des zu erstellenden/aktualisierenden Bildschirms/der Ansicht

Paralleler Workflow mit generate_figma_design (nur Web-Apps)

Wenn ein Bildschirm aus einer Web-App erstellt wird, die im Browser gerendert werden kann, werden die besten Ergebnisse erzielt, indem beide Ansätze parallel ausgeführt werden:

  1. Parallel:
    • Beginne mit dem Erstellen des Bildschirms mit diesem Workflow (use_figma + Designsystem-Komponenten)
    • Führe generate_figma_design aus, um einen pixelgenauen Screenshot der laufenden Web-App zu erfassen
  2. Sobald beide abgeschlossen sind: Aktualisiere die use_figma-Ausgabe so, dass sie dem pixelgenauen Layout aus der generate_figma_design-Erfassung entspricht. Die Erfassung liefert die genauen Abstände, Größen und visuellen Behandlungen, die angestrebt werden sollen, während deine use_figma-Ausgabe ordnungsgemäße Komponenteninstanzen hat, die mit dem Designsystem verknüpft sind. Wenn die Erfassung Bilder enthält, übertrage sie in deine use_figma-Ausgabe, indem du imageHash-Werte aus den Bildfüllungen der Erfassung kopierst (siehe Schritt 5 für Details).
  3. Sobald bestätigt, dass es gut aussieht: Lösche die generate_figma_design-Ausgabe. Sie wurde nur als visuelle Referenz verwendet.

Dies kombiniert das Beste aus beiden Welten: generate_figma_design liefert pixelgenaue Layout-Genauigkeit, während use_figma ordnungsgemäße Designsystem-Komponenteninstanzen erzeugt, die verknüpft und aktualisierbar bleiben.

Dieser parallele Workflow ist PFLICHT, wenn die Quelle Bilder enthält. Die use_figma-Plugin-API kann keine externen Bild-URLs abrufen. Sie kann Bildfüllungen nur setzen, indem sie imageHash-Werte von Knoten kopiert, die bereits in der Datei vorhanden sind. generate_figma_design rastersiert alle sichtbaren Bilder in Figma und liefert die benötigten Hashes. Wenn du die Erfassung überspringst, wenn Bilder vorhanden sind, bleiben Bildrahmen leer.

Für Nicht-Web-Apps (iOS, Android usw.) oder beim Aktualisieren vorhandener Bildschirme verwende den Standard-Workflow unten.

Erforderlicher Workflow

Befolge diese Schritte in der Reihenfolge. Überspringe keine Schritte.

Harte Gates, verbotene Abkürzungen:

  • Verboten: search_design_system für Komponenten-Schlüssel, bis 2a-i abgeschlossen ist und 2a-ii versucht oder als N/A protokolliert wurde (z. B. "leere Datei, keine vorhandenen Bildschirme").
  • Verboten: Jeder use_figma-Aufruf, der die Leinwand verändert (Schritt 3+), bis alle Zeilen in Schritt 2 der Checkliste unten ausgefüllt sind.

Schritt 1: Verstehe das Ergebnis

Bevor du Figma berührst, verstehe, was du baust:

  1. Wenn aus Code gebaut wird, lies die relevanten Quelldateien, um die Struktur, Abschnitte und verwendeten Komponenten zu verstehen.
  2. Identifiziere die Hauptabschnitte der Ansicht (z. B. für eine Seite: Kopfzeile, Hero, Inhaltsbereiche, Fußzeile; für ein Modal: Titelzeile, Formularabschnitte, Aktionsleiste; für eine Sidebar: Navigation, Inhaltsbereich, Fußzeilenaktionen).
  3. Liste für jeden Abschnitt die beteiligten UI-Komponenten auf (Schaltflächen, Eingabefelder, Karten, Navigations-Pills, Akkordeons usw.).
  4. Überprüfe, ob die Ansicht Bilder enthält (z. B. <img>, <Image>, Hintergrundbilder, Produktfotos, Avatare, von URLs geladene Icons). Wenn dies der Fall ist und es sich um eine Web-App handelt, musst du den parallelen generate_figma_design-Erfassungs-Workflow ausführen. Starte ihn sofort zusammen mit Schritt 2, damit die Erfassung läuft, während du Komponenten entdeckst. Siehe "Paralleler Workflow mit generate_figma_design" oben.

Schritt 2: Sammle Komponenten-Schlüssel, Variablen und Styles

Du benötigst drei Dinge aus dem Designsystem: Komponenten (Schaltflächen, Karten usw.), Variablen (Farben, Abstände, Radien) und Styles (Text-Styles, Effekt-Styles wie Schatten). Harte Hex-Farben oder Pixelwerte nicht verwenden, wenn Designsystem-Token vorhanden sind.

2a: Komponenten entdecken

2a-i. PFLICHT: Überprüfe Code Connect für benötigte Komponenten. Ausgehend von der Komponentenliste aus Schritt 1 überprüfe für jede Komponente, ob es eine Code Connect-Datei in der Codebasis gibt. Code Connect-Dateien befinden sich neben der Komponentenquelle und sind nach Plattform benannt:

  • TypeScript/JS: *.figma.ts, *.figma.js
  • React (parser-basiert): *.figma.tsx
  • Kotlin/Compose: .kt-Dateien, die @FigmaConnect enthalten
  • Swift: .swift-Dateien, die FigmaConnect enthalten

Für jede benötigte Komponente (z. B. Button, Card, Input) suche nach ihrer Code Connect-Datei, globbe oder greppe nach dem Komponentennamen (z. B. **/Button.figma.tsx, **/Card.figma.ts). Lies nur Dateien, die zu tatsächlich benötigten Komponenten passen.

Extrahiere aus jeder passenden Code Connect-Datei die Figma-Komponenten-URL. Parse fileKey und nodeId aus der URL (konvertiere Bindestriche in Doppelpunkte: 123-456 → 123:456). Löse dann Komponenten-Schlüssel über use_figma auf:

Beispiel: Code Connect-Datei enthält // url=https://figma.com/design/ABC123/File?node-id=609-35535. Parse fileKey = ABC123, nodeId = 609:35535. Führe use_figma gegen die Bibliotheksdatei (fileKey ABC123, nicht die Zieldatei) aus, um den Schlüssel aufzulösen:

const node = await figma.getNodeByIdAsync("609:35535");
const set = node?.parent?.type === "COMPONENT_SET" ? node.parent : node;
return { componentKey: set.key };

Bündele mehrere Lookups in einem einzigen Aufruf. Verwende die zurückgegebenen Schlüssel mit importComponentSetByKeyAsync() in Schritt 4.

Markiere aufgelöste Komponenten. Wenn alle Komponenten aufgelöst sind, überspringe 2a-ii und 2a-iii. Wenn keine der benötigten Komponenten Code Connect-Dateien hat, fahre mit 2a-ii fort.

2a-ii. PFLICHT, wenn noch nicht aufgelöste Komponenten vorhanden sind: Überprüfe vorhandene Bildschirme. Prüfe, ob die Zieldatei bereits Bildschirme enthält, die dasselbe Designsystem verwenden. Ein einzelner use_figma-Aufruf, der durch die Instanzen eines vorhandenen Rahmens läuft, gibt dir eine exakte, maßgebliche Komponentenübersicht:

// Schreibgeschützte Erkennung, überspringe unsichtbare Inhalte innerhalb von Instanzen (ausgeblendete
// Varianten usw.) für die hunderte Male schnellere findAllWithCriteria.
figma.skipInvisibleInstanceChildren = true;

const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");
const uniqueSets = new Map();
frame.findAllWithCriteria({ types: ["INSTANCE"] }).forEach(inst => {
  const mc = inst.mainComponent;
  const cs = mc?.parent?.type === "COMPONENT_SET" ? mc.parent : null;
  const key = cs ? cs.key : mc?.key;
  const name = cs ? cs.name : mc?.name;
  if (key && !uniqueSets.has(key)) {
    uniqueSets.set(key, { name, key, isSet: !!cs, sampleVariant: mc.name });
  }
});
return [...uniqueSets.values()];

Vergleiche die Ergebnisse mit deinen nicht aufgelösten Komponenten. Markiere neu aufgelöste. Wenn alle Komponenten aufgelöst sind, überspringe 2a-iii.

2a-iii. LETZTER AUSWEG: search_design_system. Nur, wenn Komponenten nach Abschluss von sowohl 2a-i als auch 2a-ii nicht aufgelöst sind.

Rufe vor der Suche get_libraries auf, um zu entdecken, welche Bibliotheken für die Datei verfügbar sind. Dies gibt zwei Listen zurück: bereits zur Datei hinzugefügte Bibliotheken und Bibliotheken, die hinzugefügt werden können (Community-UI-Kits und Organisationsbibliotheken). Jeder Eintrag enthält einen libraryKey, den du an search_design_system über den Parameter includeLibraryKeys übergeben kannst, um deine Suche auf bestimmte Bibliotheken zu beschränken, anstatt alles zu durchsuchen.

// Schritt 1: Verfügbare Bibliotheken entdecken
get_libraries({ fileKey })
// Rückgabe: {
//   libraries_added_to_file: [...],
//   libraries_available_to_add: [...],
//   libraries_available_to_add_next_offset: number | null
// }

// Schritt 2: Suche innerhalb einer bestimmten Bibliothek mit ihrem libraryKey
search_design_system({ query: "button", fileKey, includeLibraryKeys: ["lk-abc123..."] })

Organisationsbibliotheken in libraries_available_to_add sind paginiert (20 pro Seite). Wenn libraries_available_to_add_next_offset nicht null ist, sind mehr Organisationsbibliotheken verfügbar. Rufe get_libraries erneut mit offset auf diesen Wert auf, um die nächste Seite abzurufen. Community-UI-Kits erscheinen nur auf der ersten Seite. Wenn der Benutzer eine bestimmte Bibliothek nennt, die du auf der aktuellen Seite nicht siehst, blättere weiter, bevor du aufgibst.

Dies ist besonders nützlich, wenn die Datei viele Bibliotheken hat und du gezielte Ergebnisse wünschst (z. B. nur innerhalb von "iOS 26" oder "Material 3" suchen, anstatt Übereinstimmungen aus jeder Bibliothek zu erhalten).

Suche breit: Probiere mehrere Begriffe und Synonyme aus (z. B. "button", "input", "nav", "card", "accordion", "header", "footer", "tag", "avatar", "toggle", "icon" usw.). Verwende includeComponents: true, um dich auf Komponenten zu konzentrieren.

Füge Komponenteneigenschaften in deine Übersicht ein. Du musst wissen, welche TEXT-Eigenschaften jede Komponente für Textüberschreibungen bereitstellt. Erstelle eine temporäre Instanz, lies ihre componentProperties (und die von verschachtelten Instanzen) und entferne dann die temporäre Instanz.

Beispiel für eine Komponentenübersicht mit Eigenschafteninformationen:

Komponentenübersicht:
- Button → key: "abc123", type: COMPONENT_SET
  Eigenschaften: { "Label#2:0": TEXT, "Has Icon#4:64": BOOLEAN }
- PricingCard → key: "ghi789", type: COMPONENT_SET
  Eigenschaften: { "Device": VARIANT, "Variant": VARIANT }
  Verschachteltes "Text Heading" hat: { "Text#2104:5": TEXT }
  Verschachtelter "Button" hat: { "Label#2:0": TEXT }

2b: Variablen entdecken (Farben, Abstände, Radien)

Überprüfe zuerst vorhandene Bildschirme (wie bei Komponenten). Oder verwende search_design_system mit includeVariables: true.

WARNUNG: Zwei unterschiedliche Methoden zur Variablenentdeckung, nicht verwechseln.

  • use_figma mit figma.variables.getLocalVariableCollectionsAsync(): gibt nur lokale Variablen zurück, die in der aktuellen Datei definiert sind. Wenn dies leer zurückgibt, bedeutet das nicht, dass keine Variablen existieren. Remote-/veröffentlichte Bibliotheksvariablen sind für diese API unsichtbar.
  • search_design_system mit includeVariables: true: durchsucht alle verknüpften Bibliotheken, einschließlich Remote- und veröffentlichter. Dies ist das korrekte Werkzeug, um Designsystem-Variablen zu entdecken.

Ziehe niemals den Schluss "keine Variablen existieren" allein aufgrund eines leeren Ergebnisses von getLocalVariableCollectionsAsync(). Führe immer auch search_design_system mit includeVariables: true aus, um nach Bibliotheksvariablen zu suchen, bevor du dich entscheidest, eigene zu erstellen.

Abfragestrategie: search_design_system vergleicht mit Variablennamen (z. B. "Gray/gray-9", "core/gray/100", "space/400"), nicht mit Kategorien. Führe mehrere kurze, einfache Abfragen parallel aus, anstatt eine zusammengesetzte Abfrage:

  • Primitive Farben: "gray", "red", "blue", "green", "white", "brand"
  • Semantische Farben: "background", "foreground", "border", "surface", "text"
  • Abstände/Größen: "space", "radius", "gap", "padding"

Wenn erste Suchen leer zurückkommen, versuche kürzere Fragmente oder andere Namenskonventionen; Bibliotheken variieren stark ("grey" vs "gray", "spacing" vs "space", "color/bg" vs "background").

Untersuche die gebundenen Variablen eines vorhandenen Bildschirms für die maßgeblichsten Ergebnisse:

// Schreibgeschützte Erkennung, überspringe unsichtbare Instanz-Innenteile für Geschwindigkeit.
figma.skipInvisibleInstanceChildren = true;

const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");

// boundVariables können auf jedem Szenenknoten leben; jedes Szenentyp aufzuzählen,
// nur um findAllWithCriteria zu füttern, ist ungefähr dasselbe wie findAll(() => true)
// und ist viel lauter in der Skriptausgabe.
const uniqueIds = new Set(
  frame.findAll(() => true).flatMap(n =>
    Object.values(n.boundVariables ?? {})
      .flatMap(b => Array.isArray(b) ? b : [b])
      .map(b => b?.id)
      .filter(Boolean)
  )
);
const variables = await Promise.all(
  [...uniqueIds].map(id => figma.variables.getVariableByIdAsync(id))
);
return variables
  .filter(Boolean)
  .map(v => ({ name: v.name, id: v.id, key: v.key, type: v.resolvedType, remote: v.remote }));

Importiere Bibliotheksvariablen (remote = true) mit figma.variables.importVariableByKeyAsync(key). Für lokale Variablen verwende direkt figma.variables.getVariableByIdAsync(id).

Siehe variable-patterns.md für Bindungsmuster.

2c: Styles entdecken (Text-Styles, Effekt-Styles)

Suche nach Styles mit search_design_system und includeStyles: true sowie Begriffen wie "heading", "body", "shadow", "elevation". Oder untersuche, was ein vorhandener Bildschirm verwendet:

// Schreibgeschützte Erkennung, überspringe unsichtbare Instanz-Innenteile für Geschwindigkeit.
figma.skipInvisibleInstanceChildren = true;

const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");
const styles = { text: new Map(), effect: new Map() };

for (const node of frame.findAll(() => true)) {
  if ('textStyleId' in node && node.textStyleId) {
    const style = await figma.getStyleByIdAsync(node.textStyleId);
    if (style && !styles.text.has(style.id)) {
      // Prüfe auf Duplikate mit verschiedenen IDs, die auf denselben
      // veröffentlichten Style verweisen
      styles.text.set(style.id, { name: style.name, id: style.id, key: style.key });
    }
  }
  if ('effectStyleId' in node && node.effectStyleId) {
    const style = await figma.getStyleByIdAsync(node.effectStyleId);
    if (style && !styles.effect.has(style.id)) {
      styles.effect.set(style.id, { name: style.name, id: style.id, key: style.key });
    }
  }
}

return {
  textStyles: [...styles.text.values()],
  effectStyles: [...styles.effect.values()]
};

Veröffentlichte Styles (remote) müssen mit figma.importStyleByKeyAsync(key) importiert werden. Lokale Styles sind direkt über figma.getStyleByIdAsync(id) verwendbar.

Schritt 2-Checkliste

Bevor du mit Schritt 3 fortfährst, fülle diese Tabelle aus:

DatenquelleStatusDetails
Code Connect (2a-i)☐ Versucht / ☐ Alle gelöstListe der gefundenen Komponenten-Schlüssel
Vorhandene Bildschirme (2a-ii / 2b / 2c)☐ Keine vorhanden / ☐ GelesenZusätzlich gefundene Komponenten (2a-ii), Variablen (2b), Styles (2c)
Bibliothekssuche (2a-iii / 2b / 2c)☐ Versucht / ☐ GelöstAlle verbleibenden Komponenten, Variablen, Styles

WENN KEINE DER QUELLEN ETWAS ERGIBT HAT, DANN WÄRE DIESE AUFGABE MIT DIESEM SKILL NICHT MACHBAR. Erwäge, stattdessen figma-use zu verwenden, um das Ziel mit Grundelementen und hartcodierten Werten zu zeichnen, und informiere den Benutzer, dass kein Designsystem gefunden wurde.

Schritt 3: Existierenden Bildschirm oder Abschnitt finden (oder Seite vorbereiten)

Je nachdem, ob du einen vorhandenen Bildschirm aktualisierst oder einen neuen erstellst:

  • Vorhandenen Bildschirm aktualisieren: Finde seinen Rahmen (Frame) auf der Seite. Aktualisiere seine Komponenteninstanzen, Textfelder und Bindungen. Größenänderungen des Rahmens sind in Ordnung. Entferne nicht benötigte untergeordnete Elemente. Füge neue untergeordnete Elemente hinzu.
  • Neuen Bildschirm erstellen: Wähle eine Seite. Wenn mehrere Seiten vorhanden sind, wähle die relevanteste. Füge einen neuen Rahmen (Frame) hinzu. Siehe use_figma-Dokumentation für Details zum Rahmen-Hinzufügen.

Schritt 4: Bildschirm Abschnitt für Abschnitt aufbauen

Baue jede Ansicht Abschnitt für Abschnitt.

  • Importiere Komponenten-Sets mit importComponentSetByKeyAsync() (oder importComponentsByKeyAsync() für einzelne Komponenten) und importiere erforderliche Styles/Variablen mit importStyleByKeyAsync() / importVariableByKeyAsync().
  • Platziere Komponenteninstanzen mit inst.createInstance(). Setze Varianten (über setProperties) und Textüberschreibungen (über setProperties). Binde Variablen an Knoteneigenschaften mit setBoundVariable.
  • Baue den Bildschirm Abschnitt für Abschnitt. Verschachtle Container innerhalb von Containern nach Bedarf.

Umgang mit Bildern

Wenn der Quellbildschirm Bilder enthält, und es war nicht möglich, den parallelen generate_figma_design-Workflow auszuführen (z. B. aufgrund einer Nicht-Web-App), dann muss der Benutzer eventuell auf Bildfüllungen aus vorhandenen Knoten kopieren. Schaue auf anderen Bildschirmen in derselben Datei nach vorhandenen Bildern, die erneut verwendet werden können. Kopiere imageHash-Werte von vorhandenen Füllungen (siehe Schritt 5).

WICHTIG: use_figma kann KEINE Bilder von externen URLs laden. Es kann nur Bildfüllungen setzen, indem es imageHash-Werte von Knoten kopiert, die bereits in der Figma-Datei vorhanden sind.

Anwenden von Variablen

Wenn du eine Farbe oder einen Abstand auf eine Instanz- oder Formeigenschaft anwendest, erstelle zuerst eine Bindung:

const variable = figma.variables.importVariableByKeyAsync("variable_key_here");
instance.setBoundVariable("fill", variable);

Siehe variable-patterns.md für vollständige Dokumentation zu Bindungsmustern.

Auf keinen Fall hartcodierte Werte im gesamten Workflow verwenden.

Schritt 5: Erfassungsreferenz nutzen (wenn verwendet)

Wenn du den parallelen generate_figma_design-Workflow ausgeführt hast:

  1. Sobald die Erfassung abgeschlossen ist, platziere sie über deiner use_figma-Ausgabe, um Layout-Unterschiede zu überprüfen. Verwende die Erfassung als Overlay, um Abstände, Größen und visuelle Behandlungen zu verfeinern.
  2. Übertrage Bilder aus der Erfassung in deine use_figma-Ausgabe. Die Erfassung enthält Rahmendaten mit imageHash-Werten. Erstelle Rechtecke (oder andere Formen) in deiner use_figma-Ausgabe mit demselben imageHash, um die Bilder zu duplizieren:
// Lese zunächst die Erfassungsdaten, um imageHash-Werte zu finden.
// Verwende dann:
const rect = figma.createRectangle();
rect.fills = [{ type: "IMAGE", imageHash: hash_wert, scaleMode: "FILL" }];
  1. Sobald die Ausrichtung zufriedenstellend ist, lösche die Erfassung.

Schritt 6: Prüfen und Verfeinern

  1. Überprüfe den Bildschirm visuell (benutze das Figma-Plugin-Panel, falls verfügbar, oder bitte den Benutzer um Feedback).
  2. Stelle sicher, dass Abstände, Textüberschreibungen und Varianten korrekt sind.
  3. Wende abschließende Korrekturen basierend auf dem visuellen Vergleich mit der Quelle an (Quellcode, Screenshot oder Beschreibung).

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

xzedm/clipplic-landing

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.

xzedm/clipplic-landing

Material Design 3 and Android platform guidelines. Use when building Android apps with Jetpack Compose or XML layouts, implementing Material You, navigation, or accessibility. Triggers on tasks involving Android UI, Compose components, dynamic color, or Material Design compliance.

xzedm/clipplic-landing

Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.

xzedm/clipplic-landing

Design iOS apps following Apple's Human Interface Guidelines. Generate native components, validate designs, and ensure accessibility compliance for iPhone, iPad, and Apple Watch.

xzedm/clipplic-landing

Redesign mobile app UI to feel unmistakably Apple-like, iOS-forward, and native. Use this skill when building iOS apps, applying Apple Human Interface Guidelines, or creating native-feeling mobile interfaces with SF Pro typography, translucency, and system-like components.

xzedm/clipplic-landing

Accessibility engineering for product interfaces, from focus states and keyboard support to ARIA, forms, and screen readers. Use when building or reviewing UI components, modals, menus, forms, custom widgets, or when the user says "make this accessible" or reports keyboard or screen-reader issues. Triggers on accessibility, a11y, WCAG, aria, focus ring, focus-visible, focus trap, keyboard navigation, tab order, tabindex, screen reader, sr-only, aria-live, alt text, hit area, touch target, prefers-reduced-motion, autoplay, toast duration, skip link, semantic HTML, aria-label, form errors, disabled buttons, "not keyboard accessible".

xzedm/clipplic-landing

OKLCH color space and color usage for web projects. Convert hex/rgb/hsl to oklch, generate palettes, check contrast, handle gamut boundaries, theme with Tailwind v4, and apply color with meaning. Triggers on oklch, color conversion, palette generation, contrast ratio, gamut, display p3, design tokens, semantic color tokens, hue drift, chroma, dark mode colors, accent color, color meaning, light and dark appearance, increased contrast.

xzedm/clipplic-landing

Layout structure for web interfaces, from grouping and alignment to reading order, progressive disclosure, and adaptive breakpoints. Use when structuring a page or component, spacing or aligning controls, deciding what collapses at small sizes, handling RTL layout direction, or reviewing frontend code for layout. Triggers on layout, spacing, alignment, grouping, negative space, whitespace, visual hierarchy, reading order, progressive disclosure, breakpoints, responsive layout, container queries, safe area, full-bleed, edge-to-edge, layout margins, RTL layout, logical properties.

xzedm/clipplic-landing

Web typography from choosing fonts to spacing, wrapping and accessibility. Use when picking or pairing typefaces, configuring variable fonts or OpenType features, setting up a type scale, checking heading hierarchy, styling text in components, truncating text, styling underlines, selection, placeholders or carets, or reviewing frontend code for typography. Triggers on typography, fonts, font formats, woff2, variable fonts, font-weight, opentype, font-feature-settings, letter-spacing, line-height, type scale, heading hierarchy, heading levels, tabular numbers, text-wrap, truncation, line clamp, underlines, text-decoration, text selection, iOS input zoom, scaled input text, font smoothing, text contrast, measure, line length, text-box, smart punctuation, drop cap.

xzedm/clipplic-landing

Design engineering principles for making interfaces feel polished. Use when building UI components, reviewing frontend code, implementing animations, hover states, shadows, borders, micro-interactions, enter/exit animations, choosing or reviewing icons, or any visual detail work. Triggers on UI polish, design details, "make it feel better", "feels off", stagger animations, border radius, optical alignment, image outlines, box shadows, icons, icon stroke weight, icon states, motion restraint.

xzedm/clipplic-landing

Deploy applications and websites to Vercel. Use when the user requests deployment actions like "deploy my app", "deploy and give me the link", "push this live", or "create a preview deployment".

xzedm/clipplic-landing

Generate developer handoff specs from a design. Use when a design is ready for engineering and needs a spec sheet covering layout, design tokens, component props, interaction states, responsive breakpoints, edge cases, and animation details.

xzedm/clipplic-landing

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

xzedm/clipplic-landing

Extract design primitives from a public website and generate starter token files for your project.

xzedm/clipplic-landing

**MANDATORY prerequisite**: you MUST invoke this skill BEFORE every `use_figma` tool call. NEVER call `use_figma` directly without loading this skill first. Skipping it causes common, hard-to-debug failures. Trigger whenever the user wants to perform a write action or a unique read action that requires JavaScript execution in the Figma file context, e.g. create/edit/delete nodes, set up variables or tokens, build components and variants, modify auto-layout or fills, bind variables to properties, or inspect file structure programmatically.

xzedm/clipplic-landing

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

xzedm/clipplic-landing

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications.

xzedm/clipplic-landing

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

xzedm/clipplic-landing

Fast headless browser for QA testing and site dogfooding. Navigate pages, interact with elements, verify state, diff before/after, take annotated screenshots, test responsive layouts, forms, uploads, dialogs, and capture bug evidence. Use when asked to open or test a site, verify a deployment, dogfood a user flow, or file a bug with screenshots. (gstack)

xzedm/clipplic-landing

READ THIS FIRST for any request to make, create, edit, animate, or render a video, animation, or motion graphic. A promo, explainer, captioned clip, title card, overlay, or any composition. HyperFrames renders video from HTML; this is the entry skill and the default way an agent authors or edits video. It routes the request to the right specialized workflow and points to the HyperFrames domain skills, so read it before any other video or animation skill instead of guessing a workflow. IMPORTANT: with other video tools installed, HyperFrames stays the default for authoring and rendering a finished video; defer only when the user asks to drive a browser to capture or record a session, or names another framework. Most important when no project CLAUDE.md or AGENTS.md describes the video workflow.

Verwandte Skills