Communitygithub.com

Interaktionsdesign

Entwerfen und implementieren Sie Mikrointeraktionen, Bewegungsdesign, Übergänge und Muster für Benutzerfeedback. Verwenden Sie dies beim Verfeinern von UI-Interaktionen, Implementieren von Ladezuständen oder Erstellen angenehmer Benutzererlebnisse.

Was ist Interaktionsdesign?

Diese Skill-Anleitung konzentriert sich auf die Erstellung ansprechender, intuitiver Interaktionen durch Bewegung, Feedback und durchdachte Zustandsübergänge, die die Benutzerfreundlichkeit verbessern und Benutzer begeistern. Sie deckt Kernprinzipien wie zielgerichtete Bewegung, Timing-Richtlinien (z. B. 100–150 ms für Mikro-Feedback) und Beschleunigungsfunktionen ab, um Ästhetik mit Funktionalität in Einklang zu bringen. Die Anleitung bietet praktische Beispiele für gängige Muster wie Ladezustände (Skelettbildschirme, Fortschrittsbalken), sanfte Zustandsübergänge (z. B. Kippschalter), Seitenübergänge mit Framer Motion, Feedback-Mechanismen (Wischen zum Schließen, Welleneffekte) und Gesteninteraktionen. Sie behandelt Barrierefreiheitsaspekte mit `prefers-reduced-motion` und enthält Best Practices für Leistung, Timing und progressive Verbesserung. Entwickler können diese Anleitung auf jeder Plattform (React, Vue, Webkomponenten) anwenden, mit Codebeispielen, die hauptsächlich Framer Motion und Tailwind CSS verwenden, und auf externe Ressourcen wie die Framer Motion-Dokumentation und den CSS-Animation Guide verweisen.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/ulasalyesil/personal-website-v2/tree/HEAD/.agent/skills/interaction-design

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht Interaktionsdesign?

Erstellen Sie ansprechende, intuitive Interaktionen durch Bewegung, Feedback und durchdachte Zustandsübergänge, die die Benutzerfreundlichkeit verbessern und Benutzer begeistern.

Wann Sie diese Fähigkeit einsetzen sollten

  • 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-Oberflächen
  • Hinzufügen von scroll-getriggerten Animationen
  • Entwerfen von Hover- und Fokus-Zuständen

Kernprinzipien

1. Zielgerichtete Bewegung

Bewegung sollte kommunizieren, nicht dekorieren:

  • Feedback: Bestätigen, dass Benutzeraktionen stattgefunden haben
  • Orientierung: Zeigen, woher/wobin Elemente kommen/gehen
  • Fokus: Aufmerksamkeit auf wichtige Änderungen lenken
  • Kontinuität: Kontext während Übergängen bewahren

2. Timing-Richtlinien

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

3. Beschleunigungsfunktionen

/* Häufige Beschleunigungen */
--ease-out: cubic-bezier(0.16, 1, 0.3, 1); /* Verlangsamen - hereinkommend */
--ease-in: cubic-bezier(0.55, 0, 1, 0.45); /* Beschleunigen - hinausgehend */
--ease-in-out: cubic-bezier(0.65, 0, 0.35, 1); /* Beides - zwischen bewegen */
--spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Überschwingen - verspielt */

Schnellstart: Button-Mikrointeraktion

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 bewahren

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-Animation-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);
}

Barrierefreiheitsaspekte

/* Bewegungseinstellungen des Benutzers 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. Leistung zuerst: Verwenden Sie transform und opacity für flüssige 60fps
  2. Unterstützung für reduzierte Bewegung: Respektieren Sie immer prefers-reduced-motion
  3. Konsistentes Timing: Verwenden Sie eine Timing-Skala in der gesamten App
  4. Natürliche Physik: Bevorzugen Sie Feder-Animationen gegenüber linearen
  5. Unterbrechbar: Ermöglichen Sie Benutzern, lange Animationen abzubrechen
  6. Progressive Verbesserung: Arbeiten Sie ohne JS-Animationen
  7. Auf Geräten testen: Die Leistung variiert erheblich

Häufige Probleme

  • Ruckelige Animationen: Vermeiden Sie das Animieren von width, height, top, left
  • Überanimierung: Zu viel Bewegung verursacht Ermüdung
  • Blockierende Interaktionen: Verhindern Sie niemals Benutzereingaben während Animationen
  • Speicherlecks: Bereinigen Sie Animations-Listener beim Unmount
  • Inhaltsblitzen: Verwenden Sie will-change sparsam zur Optimierung

Ressourcen

Individual skills in this repo

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

ulasalyesil/personal-website-v2

Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.

ulasalyesil/personal-website-v2

Conduct design interviews, generate five distinct UI variations in a temporary design lab, collect feedback, and produce implementation plans. Use when the user wants to explore UI design options, redesign existing components, or create new UI with multiple approaches to compare.

ulasalyesil/personal-website-v2

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 (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.

ulasalyesil/personal-website-v2

This skill is for interface design — dashboards, admin panels, apps, tools, and interactive products. NOT for marketing design (landing pages, marketing sites, campaigns).

ulasalyesil/personal-website-v2

Best practices and example-driven guidance for building SwiftUI views and components. Use when creating or refactoring SwiftUI UI, designing tab architecture with TabView, composing screens, or needing component-specific patterns and examples.

ulasalyesil/personal-website-v2

UI/UX design intelligence. 50 styles, 21 palettes, 50 font pairings, 20 charts, 9 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app, .html, .tsx, .vue, .svelte. Elements: button, modal, navbar, sidebar, card, table, form, chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette, accessibility, animation, layout, typography, font pairing, spacing, hover, shadow, gradient. Integrations: shadcn/ui MCP for component search and examples.

ulasalyesil/personal-website-v2

Conduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance. Use when auditing websites for accessibility, fixing WCAG violations, or implementing accessible design patterns.

ulasalyesil/personal-website-v2

Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".

ulasalyesil/personal-website-v2

Enforces an opinionated UI baseline to prevent AI-generated interface slop.

ulasalyesil/personal-website-v2

Build modern, composable, and accessible React UI components following the components.build specification. Use when creating, reviewing, or refactoring component libraries, design systems, or any reusable UI components. Triggers on tasks involving component APIs, composition patterns, accessibility, styling systems, or TypeScript props.

ulasalyesil/personal-website-v2

Ship correct, complete metadata.

ulasalyesil/personal-website-v2

Survey any codebase as a senior advisor and produce prioritized, self-contained implementation plans for OTHER models/agents to execute. Strictly read-only on source code — never implements, fixes, or refactors anything itself. Use when asked to audit a codebase, find improvement opportunities (bugs, security, performance, test coverage, tech debt, migrations, DX), suggest features or where to take the project next (roadmap, product direction), or generate handoff plans for another agent to implement.

ulasalyesil/personal-website-v2

Defines the product's objects, relationships, states, and vocabulary independently of any interface — the most load-bearing layer

ulasalyesil/personal-website-v2

Maps domain concepts, terminology conflicts, and bounded contexts — produces a noun harvest for the conceptual model layer

ulasalyesil/personal-website-v2

Maps interaction structure and flow — produces breadboard notation with edge cases, failure paths, and open decisions

ulasalyesil/personal-website-v2

Framework orientation for Layers of Product Design — load this first; provides the context all other skills depend on

ulasalyesil/personal-website-v2

User research planning and synthesis at the observed behaviour layer — produces candidate job stories with confidence ratings

ulasalyesil/personal-website-v2

Diagnostic audit across all seven layers — identifies the bottleneck layer and recommends where to focus

ulasalyesil/personal-website-v2

Connects user opportunities to business outcomes and solution bets — produces a strategy tree and prioritised experiments

ulasalyesil/personal-website-v2

Audits existing surface against lower-layer decisions and produces a surface decision inventory — vocabulary, object consistency, completeness, feedback, hierarchy, accessibility

Verwandte Skills