Communitygithub.com

Interaktionsdesign

Entwerfe und implementiere Mikrointeraktionen, Bewegungsdesign, Übergänge und Benutzerfeedback-Muster. Verwende diese Fähigkeit, um UI-Interaktionen zu veredeln, Ladezustände zu implementieren oder bezaubernde Benutzererlebnisse zu schaffen.

Was ist Interaktionsdesign?

Diese Fähigkeit (Skill) namens 'Interaktionsdesign' (Interaction Design) dient dazu, ansprechende und intuitive Benutzeroberflächen durch den gezielten Einsatz von Bewegung, visuellem Feedback und durchdachten Zustandsübergängen zu gestalten. Sie ist besonders nützlich, um die Benutzerfreundlichkeit zu verbessern und Benutzer zu begeistern, indem sie bewährte Muster für Mikrointeraktionen, Ladezustände, Seitenübergänge und Gestensteuerung wie 'Wischen zum Schließen' bereitstellt. Der Skill unterstützt Entwickler bei der Arbeit mit Technologien wie Framer Motion und React und bietet konkrete Codebeispiele für die Implementierung von Buttons mit Federanimationen, Toggle-Schaltern, Lade-Skeletons oder Welleneffekten. Besonderer Wert wird auf Barrierefreiheit gelegt, insbesondere durch die Unterstützung der `prefers-reduced-motion`-Media-Query, sowie auf Performance-Richtlinien, die sicherstellen, dass Animationen flüssig und ressourcenschonend bleiben. Durch die Einhaltung von Kernprinzipien wie zielgerichteter Bewegung und konsistentem Timing hilft der Skill dabei, übermäßige Animationen zu vermeiden und ein ausgewogenes Benutzererlebnis zu gewährleisten.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/itsmeyaw/skillset-website/tree/HEAD/.agents/skills/interaction-design

In Ihrer bevorzugten KI fragen

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

Dokumentation

Interaktionsdesign (Interaction Design)

Erstelle fesselnde, intuitive Interaktionen durch Bewegung, Feedback und durchdachte Zustandsübergänge, die die Benutzerfreundlichkeit verbessern und Benutzer begeistern.

Wann sollte dieser Skill verwendet werden

  • Hinzufügen von Mikrointeraktionen zur Verbesserung des Benutzerfeedbacks
  • Implementieren von sanften Seiten- und Komponentenübergängen
  • Entwerfen von Ladezuständen und Skelettbildschirmen
  • Erstellen von gestenbasierten Interaktionen
  • Aufbau von Benachrichtigungs- und Toast-Systemen
  • Implementieren von Drag-and-Drop-Schnittstellen
  • Hinzufügen von scroll-getriggerten Animationen
  • Entwerfen von Hover- und Fokuszuständen

Grundlegende Prinzipien

1. Zielgerichtete Bewegung

Bewegung sollte kommunizieren, nicht dekorieren:

  • Feedback: Bestätige, dass Benutzeraktionen stattgefunden haben
  • Orientierung: Zeige, woher Elemente kommen / wohin sie gehen
  • Fokus: Lenke die Aufmerksamkeit auf wichtige Änderungen
  • Kontinuität: Behalte den Kontext während Übergängen bei

2. Timing-Richtlinien

DauerAnwendungsfall
100-150msMikro-Feedback (Hover, Klicks)
200-300msKleine Übergänge (Toggle, Dropdowns)
300-500msMittlere Übergänge (Modale, Seitenwechsel)
500ms+Komplexe choreografierte Animationen

3. Beschleunigungsfunktionen (Easing)

/* Übliche Easing-Funktionen */
--ease-out: cubic-bezier(0.16, 1, 0.3, 1); /* Verlangsamen - eintretend */
--ease-in: cubic-bezier(0.55, 0, 1, 0.45); /* Beschleunigen - austretend */
--ease-in-out: cubic-bezier(0.65, 0, 0.35, 1); /* Beides - zwischen Zuständen */
--spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Überschwingen - verspielt */

Schnellstart: Mikrointeraktion für einen Button

import { motion } from "framer-motion";

export function InteractiveButton({ children, onClick }) {
  return (
    <motion.button
      onClick={onClick}
      whileHover={{ scale: 1.02 }}
      whileTap={{ scale: 0.98 }}
      transition={{ type: "spring", stiffness: 400, damping: 17 }}
      className="px-4 py-2 bg-blue-600 text-white rounded-lg"
    >
      {children}
    </motion.button>
  );
}

Interaktionsmuster

1. Ladezustände

Skelettbildschirme: Layout während des Ladens beibehalten

function CardSkeleton() {
  return (
    <div className="animate-pulse">
      <div className="h-48 bg-gray-200 rounded-lg" />
      <div className="mt-4 h-4 bg-gray-200 rounded w-3/4" />
      <div className="mt-2 h-4 bg-gray-200 rounded w-1/2" />
    </div>
  );
}

Fortschrittsanzeigen: Bestimmten Fortschritt anzeigen

function ProgressBar({ progress }: { progress: number }) {
  return (
    <div className="h-2 bg-gray-200 rounded-full overflow-hidden">
      <motion.div
        className="h-full bg-blue-600"
        initial={{ width: 0 }}
        animate={{ width: `${progress}%` }}
        transition={{ ease: "easeOut" }}
      />
    </div>
  );
}

2. Zustandsübergänge

Toggle mit sanftem Übergang:

function Toggle({ checked, onChange }) {
  return (
    <button
      role="switch"
      aria-checked={checked}
      onClick={() => onChange(!checked)}
      className={`
        relative w-12 h-6 rounded-full transition-colors duration-200
        ${checked ? "bg-blue-600" : "bg-gray-300"}
      `}
    >
      <motion.span
        className="absolute top-1 left-1 w-4 h-4 bg-white rounded-full shadow"
        animate={{ x: checked ? 24 : 0 }}
        transition={{ type: "spring", stiffness: 500, damping: 30 }}
      />
    </button>
  );
}

3. Seitenübergänge

Framer Motion Layout-Animationen:

import { AnimatePresence, motion } from "framer-motion";

function PageTransition({ children, key }) {
  return (
    <AnimatePresence mode="wait">
      <motion.div
        key={key}
        initial={{ opacity: 0, y: 20 }}
        animate={{ opacity: 1, y: 0 }}
        exit={{ opacity: 0, y: -20 }}
        transition={{ duration: 0.3 }}
      >
        {children}
      </motion.div>
    </AnimatePresence>
  );
}

4. Feedback-Muster

Welleneffekt bei Klick:

function RippleButton({ children, onClick }) {
  const [ripples, setRipples] = useState([]);

  const handleClick = (e) => {
    const rect = e.currentTarget.getBoundingClientRect();
    const ripple = {
      x: e.clientX - rect.left,
      y: e.clientY - rect.top,
      id: Date.now(),
    };
    setRipples((prev) => [...prev, ripple]);
    setTimeout(() => {
      setRipples((prev) => prev.filter((r) => r.id !== ripple.id));
    }, 600);
    onClick?.(e);
  };

  return (
    <button onClick={handleClick} className="relative overflow-hidden">
      {children}
      {ripples.map((ripple) => (
        <span
          key={ripple.id}
          className="absolute bg-white/30 rounded-full animate-ripple"
          style={{ left: ripple.x, top: ripple.y }}
        />
      ))}
    </button>
  );
}

5. Gesteninteraktionen

Wischen zum Schließen:

function SwipeCard({ children, onDismiss }) {
  return (
    <motion.div
      drag="x"
      dragConstraints={{ left: 0, right: 0 }}
      onDragEnd={(_, info) => {
        if (Math.abs(info.offset.x) > 100) {
          onDismiss();
        }
      }}
      className="cursor-grab active:cursor-grabbing"
    >
      {children}
    </motion.div>
  );
}

CSS-Animationen-Muster

Keyframe-Animationen

@keyframes fadeIn {
  from {
    opacity: 0;
    transform: translateY(10px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

@keyframes pulse {
  0%,
  100% {
    opacity: 1;
  }
  50% {
    opacity: 0.5;
  }
}

@keyframes spin {
  to {
    transform: rotate(360deg);
  }
}

.animate-fadeIn {
  animation: fadeIn 0.3s ease-out;
}
.animate-pulse {
  animation: pulse 2s ease-in-out infinite;
}
.animate-spin {
  animation: spin 1s linear infinite;
}

CSS-Übergänge

.card {
  transition:
    transform 0.2s ease-out,
    box-shadow 0.2s ease-out;
}

.card:hover {
  transform: translateY(-4px);
  box-shadow: 0 12px 24px rgba(0, 0, 0, 0.1);
}

Barrierefreiheit

/* Benutzerpräferenzen für reduzierte Bewegung respektieren */
@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
  }
}
function AnimatedComponent() {
  const prefersReducedMotion = window.matchMedia(
    "(prefers-reduced-motion: reduce)",
  ).matches;

  return (
    <motion.div
      animate={{ opacity: 1 }}
      transition={{ duration: prefersReducedMotion ? 0 : 0.3 }}
    />
  );
}

Best Practices

  1. Performance zuerst: Verwende transform und opacity für flüssige 60fps
  2. Unterstützung für reduzierte Bewegung: Respektiere immer prefers-reduced-motion
  3. Konsistentes Timing: Verwende eine einheitliche Zeitskala in der gesamten App
  4. Natürliche Physik: Bevorzuge Feder-Animationen gegenüber linearen
  5. Unterbrechbar: Erlaube Benutzern, lange Animationen abzubrechen
  6. Progressive Verbesserung: Funktioniere auch ohne JS-Animationen
  7. Auf Geräten testen: Die Leistung variiert erheblich

Häufige Probleme

  • Ruckelige Animationen: Vermeide Animationen von width, height, top, left
  • Übermäßige Animation: Zu viel Bewegung verursacht Ermüdung
  • Blockierende Interaktionen: Verhindere niemals Benutzereingaben während Animationen
  • Speicherlecks: Räume Animations-Listener beim Unmount auf
  • Content-Flash: Verwende will-change sparsam zur Optimierung

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Verwandte Skills