Communitygithub.com

ComeOnOliver/skillshub

Utilisez lorsque l'interface utilisateur est lente, le défilement lag, les animations bégayent, ou lorsque vous demandez 'pourquoi ma vue SwiftUI est lente', 'comment optimiser les performances de List', 'mon application perd des images', 'le body de la vue est appelé trop souvent', 'List est lent' - Optimisation des performances SwiftUI avec Instruments 26 et les patterns de la WWDC 2025

Qu'est-ce que skillshub ?

Cette compétence est un guide complet d'optimisation des performances SwiftUI, ciblant les développeurs confrontés à des problèmes de réactivité de l'interface utilisateur tels que des listes lentes, des animations saccadées ou des chutes d'images. Elle explique comment utiliser le nouvel instrument SwiftUI dans Instruments 26, introduit à la WWDC 2025, pour identifier les goulots d'étranglement. La compétence couvre deux problèmes principaux : les mises à jour longues du body des vues et les mises à jour inutiles des vues. Elle propose des techniques pour analyser les causes racines via le 'Cause & Effect Graph', et des solutions pratiques comme la mise en cache des formatters et des calculs complexes hors du body de la vue. Elle détaille également les améliorations automatiques de performances d'iOS 26 pour les listes, le défilement et les ScrollViews imbriquées. Conçue pour Claude Code et d'autres agents IA, cette compétence fournit un arbre de décision pour prioriser les optimisations et comprendre les scénarios de pression, en s'appuyant sur des patterns de la WWDC 2025.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-swiftui-performance

Demander à votre IA préférée

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

Documentation

Optimisation des Performances SwiftUI

Quand Utiliser Cette Compétence

Utilisez quand :

  • L'application semble moins réactive (à-coups, blocages, défilement retardé)
  • Les animations font une pause ou sautent pendant l'exécution
  • Les performances de défilement sont médiocres
  • Le profilage révèle que SwiftUI est le goulot d'étranglement
  • Les bodies des vues prennent trop de temps à s'exécuter
  • Les vues se mettent à jour plus souvent que nécessaire
  • Vous devez comprendre la cause et l'effet des mises à jour SwiftUI

Exemples de Prompts

Voici des questions réelles que les développeurs posent et auxquelles cette compétence est conçue pour répondre :

1. "Mon application a un défilement saccadé et les animations bégayent. Comment puis-je savoir si SwiftUI en est la cause ?"

→ La compétence montre comment utiliser le nouvel instrument SwiftUI dans Instruments 26 pour identifier si SwiftUI est le goulot d'étranglement par rapport aux autres couches

2. "J'utilise le nouvel instrument SwiftUI et je vois des barres orange/rouges indiquant des mises à jour longues. Comment savoir ce qui les cause ?"

→ La compétence couvre les patterns du Graphique Cause & Effet qui montrent le flux de données à travers votre application et quels changements d'état déclenchent des mises à jour coûteuses

3. "Certaines vues se mettent à jour beaucoup trop souvent même si leurs données n'ont pas changé. Comment trouver quelles vues sont le problème ?"

→ La compétence démontre la détection des mises à jour inutiles et le dépannage d'identité avec la chronologie visuelle

4. "J'ai de grandes structures de données et des hiérarchies de vues complexes. Comment les optimiser pour les performances SwiftUI ?"

→ La compétence couvre les patterns de performance : décomposer les hiérarchies de vues, minimiser la complexité du body et utiliser la liste de vérification d'optimisation @Sendable

5. "Nous avons une date limite de performance et j'ai besoin de comprendre ce qui est lent dans SwiftUI. Quelles sont les métriques critiques ?"

→ La compétence fournit l'arbre de décision pour prioriser les optimisations et comprend les scénarios de pression avec des conseils professionnels pour les compromis


Aperçu

Principe de Base : Assurez-vous que les bodies de vos vues se mettent à jour rapidement et seulement lorsque c'est nécessaire pour obtenir d'excellentes performances SwiftUI.

NOUVEAU dans WWDC 2025 : L'instrument SwiftUI de nouvelle génération dans Instruments 26 fournit une analyse complète des performances avec :

  • Chronologie visuelle des mises à jour longues (codées en couleur orange/rouge selon la gravité)
  • Graphique Cause & Effet montrant le flux de données dans votre application
  • Intégration avec le Profileur Temporel pour l'analyse CPU
  • Suivi des Blocages et des À-coups

Problèmes de Performance Clés :

  1. Mises à jour Longues du Body de la Vue — Les bodies des vues prennent trop de temps à s'exécuter
  2. Mises à jour Inutiles de la Vue — Les vues se mettent à jour alors que les données n'ont pas réellement changé

Améliorations des Performances du Framework iOS 26

"Les améliorations de performances du framework profitent aux applications sur toutes les plateformes Apple, de notre application à la vôtre." — WWDC 2025-256

SwiftUI dans iOS 26 inclut des gains de performance majeurs qui profitent automatiquement à toutes les applications. Ces améliorations fonctionnent parallèlement aux nouveaux outils de profilage pour rendre SwiftUI plus rapide dès le départ.

Performances de List (Focus macOS)

Gains massifs pour les grandes listes

  • Chargement 6x plus rapide pour les listes de 100 000+ éléments sur macOS
  • Mises à jour 16x plus rapides pour les grandes listes
  • Gains encore plus importants pour les listes plus grandes
  • Les améliorations profitent à toutes les plateformes (iOS, iPadOS, watchOS, pas seulement macOS)
List(trips) { trip in // 100k+ éléments
    TripRow(trip: trip)
}
// iOS 26 : Chargement 6x plus rapide, mises à jour 16x plus rapides sur macOS
// Toutes les plateformes bénéficient des améliorations de performances

Impact sur votre application

  • Les grands ensembles de données (10k+ éléments) voient des améliorations notables
  • Les opérations de filtrage et de tri s'effectuent plus rapidement
  • Les mises à jour en temps réel des listes sont plus réactives
  • Profite aux applications comme les navigateurs de fichiers, les listes de contacts, les tableaux de données

Performances de Défilement

Réduction des images perdues lors du défilement à grande vitesse

SwiftUI a amélioré la planification des mises à jour de l'interface utilisateur sur iOS et macOS. Cela améliore la réactivité et permet à SwiftUI de faire encore plus de travail pour préparer les images à venir. Dans l'ensemble, cela réduit le risque que votre application perde une image lors d'un défilement rapide à des fréquences d'images élevées.

Améliorations clés

  1. Meilleure planification des images — SwiftUI a plus de temps pour préparer les images à venir
  2. Réactivité améliorée — Les mises à jour de l'interface utilisateur sont planifiées plus efficacement
  3. Moins d'images perdues — Surtout lors d'un défilement rapide à 120 Hz (ProMotion)

Quand vous le remarquerez

  • Défilement dans du contenu riche en images
  • Appareils à haute fréquence d'images (iPhone Pro, iPad Pro avec ProMotion)
  • Lignes de liste complexes avec plusieurs vues

ScrollViews Imbriquées avec Piles Paresseuses

Les carrousels de photos et le défilement multi-axes sont maintenant correctement optimisés

ScrollView(.horizontal) {
    LazyHStack {
        ForEach(photoSets) { photoSet in
            ScrollView(.vertical) {
                LazyVStack {
                    ForEach(photoSet.photos) { photo in
                        PhotoView(photo: photo)
                    }
                }
            }
        }
    }
}
// iOS 26 : Les scrollviews imbriquées retardent maintenant correctement le chargement avec les piles paresseuses
// Idéal pour les carrousels de photos, les mises en page de type Netflix, le contenu multi-axes

Avant iOS 26 Les ScrollViews imbriquées ne retardaient pas correctement le chargement du contenu des piles paresseuses, ce qui faisait que tout le contenu imbriqué se chargeait immédiatement.

Après iOS 26 Les piles paresseuses dans les ScrollViews imbriquées retardent maintenant le chargement jusqu'à ce que le contenu soit sur le point d'apparaître, correspondant au comportement des ScrollViews à un seul niveau.

Cas d'utilisation

  • Galeries de photos avec défilement horizontal/vertical
  • Lignes de catégories de type Netflix
  • Navigateurs de données multidimensionnels
  • Carrousels d'images avec défilement vertical détaillé

Améliorations de l'Instrument de Performance SwiftUI

Nouvelles pistes dans Instruments 26

L'instrument SwiftUI inclut maintenant des pistes dédiées pour :

  1. Mises à jour Longues du Body de la Vue — Identifiez les calculs de body coûteux
  2. Mises à jour Longues de la Vue Plateforme — Suivez les performances de pontage UIKit/AppKit (Mises à jour Longues Représentables)
  3. Autres Mises à jour Longues — Tous les autres types de travail long SwiftUI

Ces pistes sont couvertes en détail dans la section suivante.

Résumé des Améliorations de Performance

Gains automatiques (recompilation uniquement)

  • ✅ Chargement 6x plus rapide des listes (100k+ éléments, macOS)
  • ✅ Mises à jour 16x plus rapides des listes (macOS)
  • ✅ Réduction des images perdues lors du défilement
  • ✅ Meilleure planification des images sur iOS/macOS
  • ✅ Optimisation du chargement paresseux des ScrollViews imbriquées

Aucune modification de code nécessaire — reconstruisez avec le SDK iOS 26 pour obtenir ces améliorations.

Référence croisée Compétence SwiftUI 26 Features (swiftui-26-ref) — Guide complet de tous les changements SwiftUI iOS 26


L'Instrument SwiftUI (Instruments 26)

Pour Commencer

Prérequis :

  • Installez Xcode 26
  • Mettez à jour les appareils vers les dernières versions du système d'exploitation (support pour l'enregistrement des traces SwiftUI)
  • Compilez l'application en mode Release pour un profilage précis

Lancement :

  1. Ouvrez le projet dans Xcode
  2. Appuyez sur Commande-I pour profiler
  3. Choisissez le modèle SwiftUI dans le sélecteur de modèles
  4. Cliquez sur le bouton Enregistrer

Contenu du Modèle

Le modèle SwiftUI inclut trois instruments :

  1. Instrument SwiftUI (NOUVEAU) — Identifie les problèmes de performance dans le code SwiftUI
  2. Profileur Temporel — Affiche les échantillons de travail CPU au fil du temps
  3. Blocages et À-coups — Suit la réactivité de l'application

Pistes de l'Instrument SwiftUI

Piste 1 : Groupes de Mise à Jour

  • Montre quand SwiftUI travaille activement
  • Vide pendant les pics CPU ? → Le problème vient probablement de l'extérieur de SwiftUI

Piste 2 : Mises à jour Longues du Body de la Vue

  • Met en évidence quand la propriété body prend trop de temps
  • Problème de performance le plus courant — commencez ici

Piste 3 : Mises à jour Longues Représentables

  • Identifie les mises à jour lentes de UIViewRepresentable/NSViewRepresentable
  • Performances d'intégration UIKit/AppKit

Piste 4 : Autres Mises à jour Longues

  • Tous les autres types de travail long SwiftUI

Système de Codage Couleur

Les mises à jour sont affichées en orange et rouge en fonction de la probabilité de provoquer des à-coups :

  • Rouge — Très susceptible de contribuer à un à-coup/blocage (enquêtez en premier)
  • Orange — Modérément susceptible de causer des problèmes
  • Gris — Mises à jour normales, pas inquiétantes

Remarque : Le fait que les mises à jour entraînent ou non des à-coups dépend des conditions de l'appareil, mais les mises à jour rouges sont la priorité la plus élevée.


Comprendre la Boucle de Rendu

Rendu d'Image Normal

Image 1 :
├─ Gérer les événements (touchers, pressions de touches)
├─ Mettre à jour l'interface utilisateur (exécuter les bodies des vues)
│  └─ Terminé avant l'échéance de l'image ✅
├─ Transférer au système
└─ Le système rend → Visible à l'écran

Image 2 :
├─ Gérer les événements
├─ Mettre à jour l'interface utilisateur
│  └─ Terminé avant l'échéance de l'image ✅
├─ Transférer au système
└─ Le système rend → Visible à l'écran

Résultat : Animations fluides

Image avec À-coup (Body de Vue Long)

Image 1 :
├─ Gérer les événements
├─ Mettre à jour l'interface utilisateur
│  └─ UN BODY DE VUE TROP LENT
│  └─ Dépasse l'échéance de l'image ❌
├─ Échéance manquée
└─ L'image précédente reste visible (À-COUP)

Image 2 : (Retardée)
├─ Gérer les événements (retardés d'1 image)
├─ Mettre à jour l'interface utilisateur
├─ Transférer au système
└─ Le système rend → Enfin visible

Résultat : Image précédente visible pendant 2+ images = animation saccadée

Image avec À-coup (Trop de Mises à Jour)

Image 1 :
├─ Gérer les événements
├─ Mettre à jour l'interface utilisateur
│  ├─ Mise à jour 1 (rapide)
│  ├─ Mise à jour 2 (rapide)
│  ├─ Mise à jour 3 (rapide)
│  ├─ ... (100 autres mises à jour rapides)
│  └─ Temps total dépasse l'échéance ❌
├─ Échéance manquée
└─ L'image précédente reste visible (À-COUP)

Résultat : De nombreuses petites mises à jour s'additionnent pour manquer l'échéance

Aperçu Clé : Le temps d'exécution du body de la vue est important car le fait de manquer les échéances des images provoque des à-coups, rendant les animations moins fluides.

Référence :


Problème 1 : Mises à jour Longues du Body de la Vue

Identifier les Mises à jour Longues

  1. Enregistrez une trace dans Instruments avec le modèle SwiftUI
  2. Regardez la piste Mises à jour Longues du Body de la Vue — y a-t-il des barres orange/rouges ?
  3. Développez la piste SwiftUI pour voir les sous-pistes
  4. Sélectionnez la sous-piste Mises à jour du Body de la Vue
  5. Filtrez pour les mises à jour longues :
    • Volet Détail → Menu déroulant → Choisissez "Résumé des mises à jour longues du body de la Vue"

Analyser avec le Profileur Temporel

Flux de travail :

  1. Trouvez une mise à jour longue dans le Résumé des mises à jour longues du body de la Vue
  2. Survolez le nom de la vue → Cliquez sur la flèche → "Afficher les mises à jour"
  3. Faites un clic droit sur la mise à jour longue → "Définir la plage d'inspection et zoomer"
  4. Basculez vers la piste de l'instrument Profileur Temporel

Ce que vous voyez :

  • Piles d'appels pour les échantillons enregistrés pendant l'exécution du body de la vue
  • Temps passé dans chaque image (colonne la plus à gauche)
  • Votre body de vue imbriqué dans la pile d'appels SwiftUI profonde

Trouver le goulot d'étranglement :

  1. Option-clic pour développer la pile d'appels du thread principal
  2. Commande-F pour rechercher le nom de votre vue (par exemple, "LandmarkListItemView")
  3. Identifiez les opérations coûteuses dans la colonne de temps

Opérations Coûteuses Courantes

Création de Formatters (Très Coûteux)

❌ MAUVAIS - Créer des formatters dans le body de la vue :

struct LandmarkListItemView: View {
    let landmark: Landmark
    @State private var userLocation: CLLocation

    var distance: String {
        // ❌ Création de formatters à chaque exécution du body
        let numberFormatter = NumberFormatter()
        numberFormatter.maximumFractionDigits = 1

        let measurementFormatter = MeasurementFormatter()
        measurementFormatter.numberFormatter = numberFormatter

        let meters = userLocation.distance(from: landmark.location)
        let measurement = Measurement(value: meters, unit: UnitLength.meters)
        return measurementFormatter.string(from: measurement)
    }

    var body: some View {
        HStack {
            Text(landmark.name)
            Text(distance) // Appelle la propriété distance coûteuse
        }
    }
}

Pourquoi c'est lent :

  • Les formatters sont coûteux à créer (millisecondes chacun)
  • Créés chaque fois que le body de la vue s'exécute
  • S'exécute sur le thread principal → l'application attend avant de continuer les mises à jour de l'interface utilisateur
  • Plusieurs vues → le temps s'accumule rapidement

✅ CORRECT - Mettre en cache les formatters de manière centralisée :

@Observable
class LocationFinder {
    private let formatter: MeasurementFormatter
    private let landmarks: [Landmark]
    private var distanceCache: [Landmark.ID: String] = [:]

    init(landmarks: [Landmark]) {
        self.landmarks = landmarks

        // Créez les formatters UNE FOIS pendant l'initialisation
        let numberFormatter = NumberFormatter()
        numberFormatter.maximumFractionDigits = 1

        self.formatter = MeasurementFormatter()
        self.formatter.numberFormatter = numberFormatter

        updateDistances()
    }

    func didUpdateLocations(_ locations: [CLLocation]) {
        guard let location = locations.last else { return }
        updateDistances(from: location)
    }

    private func updateDistances(from location: CLLocation? = nil) {
        guard let location else { return }

        for landmark in landmarks {
            let meters = location.distance(from: landmark.location)
            let measurement = Measurement(value: meters, unit: UnitLength.meters)
            distanceCache[landmark.id] = formatter.string(from: measurement)
        }
    }

    func distanceString(for landmarkID: Landmark.ID) -> String {
        distanceCache[landmarkID] ?? "Inconnu"
    }
}

struct LandmarkListItemView: View {
    let landmark: Landmark
    @Environment(LocationFinder.self) private var locationFinder

    var body: some View {
        HStack {
            Text(landmark.name)
            Text(locationFinder.distanceString(for: landmark.id)) // ✅ Recherche rapide
        }
    }
}

Avantages :

  • Formatters créés une fois, réutilisés pour tous les points de repère
  • Chaînes pré-calculées lorsque la localisation change
  • Le body de la vue lit simplement la valeur mise en cache (instantané)
  • Mises à jour longues du body de la vue éliminées

Autres Opérations Coûteuses

Calculs Complexes :

// ❌ Ne calculez pas dans le body de la vue
var body: some View {
    let result = expensiveAlgorithm(data) // Calculs complexes, tris, etc.
    Text("\(result)")
}

// ✅ Calculez dans le modèle, mettez en cache le résultat
@Observable
class ViewModel {
    private(set) var result: Int = 0

    func updateData(_ data: [Int]) {
        result = expensiveAlgorithm(data) // Calculez une fois
    }
}

E/S Réseau/Fichier :

// ❌ Ne JAMAIS faire d'E/S dans le body de la vue
var body: some View {
    let data = try? Data(contentsOf: fileURL) // ❌ E/S synchrone
    // ...
}

// ✅ Chargez de manière asynchrone

Identité et AnyView

AnyView efface les informations de type, ce qui empêche SwiftUI de suivre correctement l'identité de la vue, entraînant des mises à jour inutiles.

Mauvais - Utiliser AnyView :

var body: some View {
    if condition {
        AnyView(Text("Condition vraie"))
    } else {
        AnyView(Text("Condition fausse"))
    }
}

Bon - Utiliser ViewBuilder :

@ViewBuilder
var body: some View {
    if condition {
        Text("Condition vraie")
    } else {
        Text("Condition fausse")
    }
}

Problème 2 : Mises à jour Inutiles

Comprendre quand les vues se mettent à jour

SwiftUI met à jour une vue lorsque sa dépendance change. Cependant, les mises à jour peuvent se propager de manière excessive.

Pourquoi les vues se mettent à jour

  1. Changement d'état -> @State, @Binding, @StateObject, @ObservedObject
  2. Propriété d'entrée -> let ou var de la vue parente
  3. Environnement -> @EnvironmentObject, @Environment
  4. Mise à jour forcée -> .id() change

Détecter les mises à jour inutiles

  1. Enregistrez une trace
  2. Regardez la piste Groupes de Mise à Jour
  3. Développez-la pour voir le nombre de mises à jour par vue
  4. Cherchez les vues avec un nombre élevé de mises à jour mais peu de changements de données

Patterns Courants de Mises à jour Inutiles

Vue avec @ObservedObject redondant

Mauvais :

struct ChildView: View {
    @ObservedObject var viewModel: ViewModel  // Observe TOUT l'objet
    
    var body: some View {
        Text(viewModel.title)  // Se met à jour même si seulement `otherProperty` change
    }
}

Bon :

struct ChildView: View {
    let title: String  // Passez uniquement ce dont vous avez besoin
    
    var body: some View {
        Text(title)
    }
}

Identité et Clés

Une mauvaise gestion de l'identité peut faire que SwiftUI reconstruise des vues entières au lieu de les mettre à jour.

Mauvais - Identité instable :

ForEach(items, id: \.self) { item in  // Utiliser l'identité implicite
    ItemView(item: item)
}

Bon - Identité stable :

ForEach(items, id: \.id) { item in  // Utiliser un identifiant explicite unique
    ItemView(item: item)
}

Recherche d'identité dans Instruments :

  • Piste "Identité de la Vue" (si disponible) montre quand les vues sont déplacées, supprimées ou réinsérées
  • Cherchez des reconstructions inutiles

Arbre de Décision pour l'Optimisation

Processus de Priorisation

  1. Exécutez Instruments 26 avec le modèle SwiftUI
  2. Cherchez les barres ROUGES sur la piste Mises à jour Longues du Body de la Vue
  3. Si trouvé ROUGE :
    • Utilisez le Profileur Temporel pour identifier l'opération coûteuse
    • Corrigez en déplaçant le travail coûteux hors du body de la vue
  4. Si seulement ORANGE :
    • Combien de pics orange ? Beaucoup (10+) ou peu (1-2) ?
    • Beaucoup : concentrez-vous sur la réduction du nombre de mises à jour
    • Peu : concentrez-vous sur l'accélération de chaque mise à jour
  5. Si les barres sont GRISES :
    • Le problème n'est probablement pas dans SwiftUI
    • Cherchez des problèmes d'E/S, de réseau ou de rendu personnalisé

Scénarios de Pression

Application avec des données volumineuses (10k+ éléments) :

  • Assurez-vous d'utiliser LazyVStack/LazyHStack
  • Envisagez de paginer les données
  • Utilisez une identification stable pour les listes

Application avec des animations complexes :

  • Utilisez .drawingGroup() pour le rendu GPU si approprié
  • Limitez les vues modifiées par des animations
  • Utilisez .animation(nil, value: ...) pour éviter des animations inutiles

Application avec des mises à jour fréquentes (ex. données en temps réel) :

  • Regroupez les mises à jour
  • Utilisez .debounce() ou .throttle() sur les éditeurs
  • Envisagez DispatchQueue.main.async pour les mises à jour non urgentes

Références

  • WWDC 2025 Session 256 : Performances SwiftUI — Le tableau de bord complet
  • Instruments 26 Documentation : Profilage des performances de l'interface utilisateur
  • Comprendre les à-coups dans votre application
  • Compétence SwiftUI 26 Features (swiftui-26-ref) — Changements de l'API SwiftUI iOS 26

Individual skills in this repo

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

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills associés