Communitygithub.com

Conception d'Interactions

Concevez et implémentez des micro-interactions, du motion design, des transitions et des schémas de retour utilisateur. À utiliser pour peaufiner les interactions UI, implémenter des états de chargement ou créer des expériences utilisateur agréables.

Qu'est-ce que Conception d'Interactions ?

Cette compétence permet de concevoir et d'implémenter des interactions UI fluides et engageantes grâce au motion design, aux micro-interactions et aux transitions d'état. Elle est essentielle pour tout développeur souhaitant ajouter du raffinement à ses interfaces utilisateur, que ce soit pour des boutons animés, des indicateurs de progression, des transitions de page ou des interactions gestuelles. La compétence fournit des exemples de code utilisant Framer Motion et CSS, avec des directives sur le timing, les fonctions d'easing, et les schémas d'interaction courants (états de chargement, retours visuels, swipe, etc.). Elle insiste également sur l'accessibilité avec `prefers-reduced-motion` et les bonnes pratiques pour des animations performantes (transform/opacity, animations interrompibles). Les développeurs peuvent l'utiliser avec des frameworks comme React (avec Framer Motion) ou en CSS pur, et elle est compatible avec Claude Code, Cursor, Codex ou tout outil d'IA agent qui génère du code front-end.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Conception d'Interactions ?

Créez des interactions engageantes et intuitives grâce au mouvement, au retour utilisateur et à des transitions d'état réfléchies qui améliorent l'utilisabilité et ravissent les utilisateurs.

Quand Utiliser Cette Compétence

  • Ajouter des micro-interactions pour améliorer le retour utilisateur
  • Implémenter des transitions fluides de page et de composant
  • Concevoir des états de chargement et des squelettes (skeleton screens)
  • Créer des interactions basées sur les gestes
  • Mettre en place des systèmes de notification et de toast
  • Implémenter des interfaces glisser-déposer
  • Ajouter des animations déclenchées par le défilement
  • Concevoir des états de survol et de focus

Principes Fondamentaux

1. Mouvement Utile

Le mouvement doit communiquer, pas décorer :

  • Retour : Confirmer que les actions de l'utilisateur ont eu lieu
  • Orientation : Montrer d'où viennent / où vont les éléments
  • Attention : Diriger l'attention vers les changements importants
  • Continuité : Maintenir le contexte pendant les transitions

2. Directives de Temporisation

DuréeCas d'utilisation
100-150msMicro-retour (survols, clics)
200-300msPetites transitions (interrupteurs, menus déroulants)
300-500msTransitions moyennes (modales, changements de page)
500ms+Animations chorégraphiées complexes

3. Fonctions d'Assouplissement (Easing)

/* Assouplissements courants */
--ease-out: cubic-bezier(0.16, 1, 0.3, 1); /* Décélération - entrée */
--ease-in: cubic-bezier(0.55, 0, 1, 0.45); /* Accélération - sortie */
--ease-in-out: cubic-bezier(0.65, 0, 0.35, 1); /* Les deux - déplacement */
--spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Dépassement - ludique */

Démarrage Rapide : Micro-Interaction de Bouton

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

Schémas d'Interaction

1. États de Chargement

Écrans Squelette : Préservez la mise en page pendant le chargement

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

Indicateurs de Progression : Affichez la progression déterminée

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. Transitions d'État

Interrupteur avec transition fluide :

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. Transitions de Page

Animations de mise en page avec Framer Motion :

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. Schémas de Retour Utilisateur

Effet de vague (ripple) au clic :

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. Interactions Gestuelles

Balayer pour fermer :

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

Schémas d'Animation CSS

Animations par Images Clés (Keyframes)

@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;
}

Transitions CSS

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

Considérations d'Accessibilité

/* Respecter les préférences de mouvement de l'utilisateur */
@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 }}
    />
  );
}

Bonnes Pratiques

  1. Performance d'Abord : Utilisez transform et opacity pour des 60fps fluides
  2. Prise en Charge du Mouvement Réduit : Respectez toujours prefers-reduced-motion
  3. Temporisation Cohérente : Utilisez une échelle de temporisation dans toute l'application
  4. Physique Naturelle : Préférez les animations ressort (spring) aux animations linéaires
  5. Interruptible : Permettez aux utilisateurs d'annuler les longues animations
  6. Amélioration Progressive : Fonctionnez sans animations JS
  7. Test sur Appareils : Les performances varient considérablement

Problèmes Courants

  • Animations Saccadées : Évitez d'animer width, height, top, left
  • Sur-animation : Trop de mouvement provoque de la fatigue
  • Interactions Bloquantes : N'empêchez jamais la saisie utilisateur pendant les animations
  • Fuite Mémoire : Nettoyez les écouteurs d'animation lors du démontage
  • Flash de Contenu : Utilisez will-change avec parcimonie pour l'optimisation

Ressources

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

Skills associés