Communitygithub.com

Cozythecoder/frontend-design-md

Projekttyp automatisch erkennen, Absichten analysieren und das optimale Designsystem aus über 60 Referenzmustern anwenden.

Was ist frontend-design-md?

Dieser Skill automatisiert die Auswahl und Anwendung von Designsystemen für Webprojekte. Er analysiert zunächst den Projekttyp (z. B. SaaS-Landingpage, Dashboard, E-Commerce) und den aktuellen Zustand des Codes (Farben, Typografie, Komponenten). Anschließend gleicht er die Analyse mit einer Bibliothek von über 60 Referenzdesigns ab (z. B. Linear, Vercel, Apple) und berechnet einen Konfidenzwert für die beste Übereinstimmung. Der Skill führt eine Pre-Flight-Prüfung durch (Assets, technische Einschränkungen) und passt das ausgewählte Designsystem intelligent an – ohne blindes Kopieren. Abschließend validiert er die Umsetzung mit Qualitäts-, Barrierefreiheits- und Leistungschecks. Unterstützt werden Frameworks wie React, Vue und Vanilla sowie CSS-Ansätze wie Tailwind, SCSS oder CSS-in-JS. Ideal für Entwickler, die schnell konsistente, professionelle UIs erstellen möchten, ohne jedes Detail manuell entwerfen zu müssen.

Funktioniert mit✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/Cozythecoder/frontend-design-md/tree/HEAD/skills/design-systems

In Ihrer bevorzugten KI fragen

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

Dokumentation

Skill: Designsystem-Intelligenz

Automatisch den Projekttyp erkennen, die Absicht analysieren und das optimale Designsystem aus über 60 Referenzmustern anwenden.

Automatische Auslöser

Dieser Skill wird aktiviert, wenn:

  • Der Benutzer eine Webprojektdatei (HTML, CSS, JS, JSX, Vue, Svelte) erstellt oder ändert.
  • Der Benutzer sagt „Design dies“, „mach es schön“, „UI verbessern“, „Designsystem anwenden“.
  • Der Benutzer spezifische Kategorien erwähnt: „Landingpage“, „Dashboard“, „Portfolio“, „E-Commerce“.
  • Im Projekt ist kein explizites Designsystem angegeben.

Phase 1: Projektanalyse (Automatisch)

Führe IMMER eine Analyse durch, bevor ein Designsystem ausgewählt wird.

Schritt 1: Projektkategorie erkennen

Scanne die Projektdateien, um den Typ zu bestimmen:

# Prüfe auf Indikatoren
detections = {
    'saas-landingpage': ['preise', 'anmelden', 'funktionen', 'hero', 'testimonials'],
    'dashboard-app': ['dashboard', 'diagramm', 'tabelle', 'sidebar', 'widget'],
    'e-commerce': ['produkt', 'warenkorb', 'kasse', 'shop', 'lagerbestand'],
    'portfolio': ['portfolio', 'galerie', 'projekt', 'kreativ', 'kunst'],
    'content-publikation': ['blog', 'artikel', 'beitrag', 'content', 'newsletter'],
    'marken-showcase': ['marke', 'geschichte', 'ueber-uns', 'mission', 'werte'],
    'entwickler-tool': ['api', 'dokumentation', 'code', 'terminal', 'github'],
    'dienstleistung-unternehmen': ['dienstleistung', 'kontakt', 'prozess', 'team', 'beratung']
}

Schritt 2: Aktuellen Zustand analysieren

Prüfe vorhandene Design-Tokens:

  • Farben in der CSS/SCSS/Tailwind-Konfiguration
  • Typografie (font-family, font-size-Deklarationen)
  • Abstände (margin, padding, gap-Muster)
  • Komponenten (Button-Klassen, Card-Klassen)

Schritt 3: Mit der Designsystem-Bibliothek abgleichen

Vergleiche mit über 60 Referenzmustern:

ProjekttypEmpfohlene Designsysteme
SaaS-Landingpagelinear.app, vercel.com, supabase.com, stripe.com, notion.so
Dashboard/Applinear.app (UI), github.com, vercel.com/dashboard, supabase.com/dashboard
E-Commerceapple.com, shopify.com, nike.com
Portfolioframer.com, webflow.com, cargo.site
Content/Blogmedium.com, substack.com, stripe.com/blog
Entwickler-Toolvercel.com, github.com, docs.rs, nextjs.org
Dienstleistungs-Unternehmencursor.com, intercom.com, webflow.com
Marke/Agenturtesla.com, apple.com, nike.com

Schritt 4: Konfidenzberechnung

Berechne die Übereinstimmungswahrscheinlichkeit:

confidenz = (
  kategorieuebereinstimmung * 0.40 +      # Passt der Inhalt?
  tokenaehnlichkeit * 0.30 +              # Überschneiden sich Farben/Typografie?
  komponentenmuster * 0.20 +              # Button/Card-Muster?
  layoutstruktur * 0.10                   # Grid/Flex-Muster?
)

Wenn confidenz > 0.75: Automatisch die beste Übereinstimmung vorschlagen
Wenn 0.50-0.75: 2-3 Alternativen anbieten
Wenn < 0.50: Benutzer nach Kategoriepräferenz fragen

Phase 2: Pre-Flight-Protokoll

Asset-Inspektions-Checkliste

BEVOR ein Designsystem angewendet wird:

  1. Prüfe auf project-context.md

    • Existiert die Datei im Projektstammverzeichnis?
    • Wenn nein: Erstelle aus einer Vorlage mit Projektname, Ziel, Zielgruppe
  2. Analysiere aktuelle Assets

    # Wird automatisch ausgeführt
    python3 ~/.claude/skills/design-systems/scripts/inspect-project.py
    

    Prüfungen:

    • Logo vorhanden? (SVG bevorzugt)
    • Produktbilder? (transparente PNGs für Hero?)
    • Farbschema bereits definiert?
    • Typografie bereits festgelegt?
    • Vorhandene Komponentenbibliothek?
  3. Bestimme die Kompositionshierarchie

    • Hero-Element: Größtes visuelles Element (Produktfoto, Illustration, Überschrift)
    • Unterstützende Elemente: Funktionen, Vorteile, soziale Beweise
    • Akzente: Dekorative Elemente, Muster
  4. Validiere technische Einschränkungen

    • Framework erkannt (React, Vue, Vanilla usw.)
    • CSS-Ansatz (Tailwind, CSS-in-JS, SCSS usw.)
    • Animationsfähigkeit (GSAP geladen? Framer Motion?)
    • Performance-Budget (mobile-first? desktop?)

Phase 3: Anwendung des Designsystems

Schritt 1: Auswählen und Laden

Basierend auf der Analyse das empfohlene DESIGN.md laden:

Empfohlen: Linear.app Designsystem
Konfidenz: 87%

Übereinstimmungsgründe:
- SaaS-Landingpage erkannt (Preise, Funktionen)
- Dark-Mode-Präferenz erkannt
- Saubere Typografie (Inter-ähnlich) gefunden
- Kartenbasierte Layout-Muster vorhanden

Schritt 2: An das Projekt anpassen

NICHT einfach roh kopieren. Basierend auf der Projektanalyse anpassen:

Farben:

  • Wenn das Projekt Markenfarben hat: Diese in die Rollen des Designsystems einordnen
  • Wenn keine Farben vorhanden: Die Palette des Designsystems direkt verwenden
  • Beispiel: „Dein Blau #3B82F6 → Primäre Akzentfarbe“

Typografie:

  • Wenn Inter/System verwendet wird: Die Schriftgrößenskalierung des Designsystems beibehalten
  • Wenn eine andere Schriftart verwendet wird: Größen/Gewichte anpassen
  • Beispiel: „Roboto statt Inter → Gewichte anpassen 400→500“

Abstände:

  • Vorhandene Abstandsskalierung prüfen
  • In das Designsystem einordnen oder beibehalten, wenn konsistent

Komponenten:

  • Vorhandene Klassen auf die Muster des Designsystems abbilden
  • Beispiel: „Dein .btn-primary → Primärer Button des Designsystems“

Schritt 3: Implementierungs-Checkliste

Wende das Designsystem in der Prioritätsreihenfolge an:

  1. Grundlagen (Kritisch)

    • CSS-Farbvariablen zugeordnet
    • Typografie-Skalierung definiert
    • Abstandssystem etabliert
    • Basis-Reset/Normalize angewendet
  2. Layout (Hoch)

    • Bereichsabstände (Hero, Inhalt, Footer)
    • Containerbreiten (max-width, padding)
    • Grid-System (falls zutreffend)
  3. Komponenten (Mittel)

    • Buttons (primär, sekundär, Geist)
    • Cards (falls verwendet)
    • Formulare/Eingabefelder (falls verwendet)
    • Navigation (Header, Footer)
  4. Feinschliff (Niedrig)

    • Schatten/Höhenstaffelung
    • Einheitliche border-radius
    • Fokus-Zustände
    • Hover-Übergänge

Phase 4: Validierung

Qualitätsprüfungen

Nach der Anwendung ausführen:

Prüfung auf visuelle Konsistenz:

# Prüfe auf Verstöße
verstoesse = []

# 1. Anzahl der Farben
if einzigartige_farben > 8:
    verstoesse.append("Zu viele Farben – Palette vereinfachen")

# 2. Typografie-Skalierung
if schriftgroessen > 12:
    verstoesse.append("Typografie nicht systematisch – Größen konsolidieren")

# 3. Abstandskonsistenz
if abstandsbasis not in [4, 8, 16]:
    verstoesse.append("Abstände folgen nicht dem 4/8px-Raster")

# 4. Touch-Ziele
if touch_ziele < 44:
    verstoesse.append("Touch-Ziele unter 44px")

Barrierefreiheitsprüfung:

  • Farbkontrast >= 4,5:1 für Text
  • Fokus-Indikatoren sichtbar
  • reduced-motion wird respektiert
  • ARIA-Labels wo nötig

Leistungsprüfung:

  • Keine layout-erschütternden Animationen
  • Bilder optimiert
  • Schriftarten subsettiert (falls benutzerdefiniert)

Referenzen

Designsystem-Analyse

Anpassungsleitfäden

Validierung

Kategoriespezifische Muster

Skripte

  • scripts/analyze-project.py – Kategorie und aktuelle Tokens erkennen
  • scripts/match-design-system.py – Mit der Bibliothek abgleichen
  • scripts/validate-application.py – Qualitätsprüfungen
  • scripts/generate-adaptation.py – Vorhandenes auf das Designsystem abbilden
  • scripts/inspect-assets.py – Bilder, Logos, Marken-Assets prüfen

Designsystem-Bibliothek

Über 60 Systeme, organisiert nach Kategorie in ../design-systems/:

SaaS / Entwickler-Tools

  • linear.app (dunkel, Inter, 510er Gewicht)
  • vercel.com (Geist, Schatten-Rand)
  • supabase.com (warm, postgres-inspiriert)
  • stripe.com (contentreich, Verläufe)
  • notion.so (freundlich, abgerundet)
  • github.com (funktional, dicht)
  • cursor.com (editor-fokussiert, Syntaxfarben)

E-Commerce / Produkt

  • apple.com (SF Pro, binärer Kontrast, Pill-CTA)
  • shopify.com (polarisiert, Polaris-Tokens)
  • nike.com (gewagt, dynamisch, bilderstark)

Kreativ / Portfolio

  • framer.com (verspielt, Verläufe, schwungvoll)
  • webflow.com (professionell, strukturiert)

Content / Publikation

  • medium.com (lesefokussiert, Serifen-Körper)
  • substack.com (warm, newsletter-zentriert)

Enterprise

  • ibm.com (Carbon-Design, systematisch)
  • salesforce.com (funktional, dicht)

Automobil / Luxus

  • tesla.com (minimal, produktzentriert)
  • ferrari.com (dramatisch, roter Akzent)
  • bmw.com (technisch, präzise)

Nutzungsablauf

Benutzer: „Erstelle eine Landingpage für mein SaaS“
↓
Skill: Analysiert Projekt...
       Erkennt: SaaS-Landingpage-Absicht
       Aktueller Zustand: Kein Designsystem
↓
Skill: Empfiehlt linear.app (87% Übereinstimmung)
       Bietet Alternativen: vercel.com, stripe.com
↓
Benutzer: „Verwende Linear-Stil“
↓
Skill: Führt Pre-Flight-Protokoll aus
       - Erstellt project-context.md
       - Analysiert Assets
       - Prüft Tech-Stack
↓
Skill: Wendet Linear-Designsystem an
       - Ordnet Farb-Tokens zu
       - Legt Typografie-Skalierung fest
       - Implementiert Komponenten
↓
Skill: Validiert Ausgabe
       - Farbkontrastprüfung
       - Abstandskonsistenz
       - Qualitätsprüfungs-Review
↓
Ausgabe: Projekt mit Linear-inspiriertem Design

Konfiguration

Überschreibe die automatische Erkennung durch Erstellen einer .design-system-Datei im Projektstammverzeichnis:

{
  "system": "linear.app",
  "theme": "dark",
  "adaptations": {
    "primaryColor": "#3B82F6",
    "fontFamily": "Inter"
  }
}

Dieser Skill vereint deine Sammlung von über 60 Designsystemen mit einem epischen Workflow: automatische Erkennung, Pre-Flight-Checks, Validierung und intelligente Anpassung.

Verwandte Skills