Communitygithub.com

CharbelElBateh/personal-website

Comment écrire du Swift moderne de manière idiomatique — modélisation avec types valeur, sécurité de concurrence de Swift 6, protocoles et génériques, conception d'API, performance, Swift Testing, macros, et les fonctionnalités modernes que les agents ne connaissent pas encore. À utiliser lors de l'écriture, la révision ou la migration de Swift, ou lorsqu'une erreur de concurrence, un blocage, une course de données, un cycle de rétention ou un problème de performance nécessite une correction.

Qu'est-ce que personal-website ?

Ce skill est un guide complet pour écrire du Swift moderne, couvrant les fonctionnalités jusqu'à Swift 6.4. Il est conçu pour les développeurs qui souhaitent exploiter toute la puissance du langage, en particulier les agents d'IA (comme Claude Code, Cursor, Codex) qui ont besoin de conseils précis lors de la génération, la révision ou la migration de code Swift. Le skill met l'accent sur une approche de divulgation progressive : commencer par la solution la plus simple et la plus statique (structs, types concrets, exécution synchrone sur l'acteur principal), et n'introduire de la complexité (classes, protocoles, concurrence, pointeurs) que lorsqu'elle est justifiée par des mesures de performance ou des besoins spécifiques. Il détaille la modélisation avec des types valeur, les règles de concurrence de Swift 6.2 (où `async` ne déplace pas le travail en arrière-plan, contrairement à `@concurrent`), la sécurité des données avec `Sendable`, et l'utilisation correcte des acteurs, des tâches structurées et de la gestion de la mémoire (ARC, copy-on-write). Le skill est particulièrement utile pour corriger les erreurs de concurrence, les courses de données, les cycles de rétention, et pour adopter les nouvelles fonctionnalités comme les types non copiables, les macros, et Swift Testing. Il s'applique à tout projet Swift, qu'il s'agisse d'un package, d'une application iOS/macOS ou d'un service backend.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/CharbelElBateh/personal-website/tree/HEAD/.claude/skills/write-swift

Demander à votre IA préférée

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

Documentation

Écrire du Swift

Réponse initiale

Lorsque ce skill est invoqué pour la première fois sans question spécifique, répondez uniquement par :

Je suis prêt à vous aider à écrire du Swift moderne, de la manière dont le langage veut être écrit.

Ne fournissez aucune autre information jusqu'à ce que l'utilisateur pose une question.

Comment écrire Swift de la manière dont le langage veut être écrit, à jour jusqu'à Swift 6.4.

Base de la chaîne d'outils : Swift 6.3 (version actuelle en août 2026). Tout ceci compile sous 6.3 sauf indication contraire ⚠, qui signale les fonctionnalités non encore publiées de Swift 6.4. Les conseils sur la concurrence supposent le modèle Swift 6.2 — si le projet est sur 6.1 ou antérieur, les règles du §3 concernant async et @concurrent ne s'appliquent pas.

Le fil conducteur : Swift est un langage à divulgation progressive. Commencez par la chose la plus simple, la plus statique, la plus mono-thread qui fonctionne, et n'achetez du dynamisme — concurrence, sémantique de référence, existentiels, pointeurs dangereux — que là où vous pouvez pointer une raison. Chaque règle ci-dessous est une application de ce principe.

Modélisez cette hiérarchie de valeurs par défaut. Ne descendez d'un niveau qu'avec une raison que vous pouvez énoncer :

BesoinUtilisezDescendez seulement lorsque
Donnéesstruct / enumvous avez besoin d'identité, de partage ou d'héritage
Abstractiontype concretvous avez du code répété entre types
Polymorphismesome P (générique)vous avez besoin de stockage hétérogène → any P
Exécutionacteur principal, synchronele profilage montre un blocage → async → @concurrent → actor
MémoireArray, Stringle profilage montre le coût → InlineArray, Span
SécuritéAPI sécuriséeinterop C ou un chemin chaud mesuré → Unsafe*

1. Modéliser les données avec des types valeur

Les types valeur sont la valeur par défaut en Swift, pas un cas particulier.

  • Utilisez struct et enum par défaut. N'utilisez class que pour l'identité, l'état mutable partagé, l'héritage ou la durée de vie d'une ressource. Une fenêtre, une connexion à une base de données, une entité stockée dans un moteur de rendu — celles-ci ont une identité. Un Point, une Boisson, un Matériau n'en ont pas.
  • let par défaut ; var seulement lorsque vous mutez. C'est la même discipline que some avant any et valeur avant référence : commencez étroit, élargissez avec une raison.
  • Une struct avec une propriété de type référence mutable n'est ni une valeur ni une référence. Les copies partagent l'objet ; les mutations se propagent entre les copies. Soit gardez le type référencé immuable, exposez uniquement des propriétés calculées qui lui délèguent, soit faites-en une propriété private stockée derrière une copie à l'écriture.
  • La copie à l'écriture est la façon d'obtenir un stockage hors ligne et une sémantique de valeur. Encapsulez une classe finale dans une struct et vérifiez isKnownUniquelyReferenced(&stockage) avant de muter ; copiez d'abord si ce n'est pas le cas. C'est exactement ainsi que fonctionnent Array, String et Dictionary.
  • Les enums sont l'outil pour « un ensemble fixe de choses » et pour les états mutuellement exclusifs. Remplacer un tas de propriétés stockées optionnelles (isPartage, lignesSelectionnees, ciblePartage) par une enum Etat rend les combinaisons invalides irreprésentables et rend le changement d'état atomique au lieu d'une séquence d'écritures de propriétés que vous pouvez oublier de terminer.
  • Composer des valeurs produit une valeur. Une struct dont les propriétés stockées sont toutes des types valeur a une sémantique de valeur gratuitement — ce qui fait de l'annulation, du diff et de la restauration d'état un seul chemin de code au lieu d'un par propriété.
struct Materiau {                       // sémantique de valeur préservée
  var rugosite: Double
  private var _texture: Texture         // une classe

  var couleur: Couleur {
    get { _texture.couleur }
    set {
      if !isKnownUniquelyReferenced(&_texture) { _texture = Texture(copiant: _texture) }
      _texture.couleur = nouvelleValeur
    }
  }
}

Les types non copiables (~Copyable) expriment une propriété unique : un descripteur de fichier, un virement bancaire, une ressource ouverte. Supprimer la copie transforme « vous ne devez pas exécuter ceci deux fois » d'une assertion en une erreur de compilation, et donne un sens à deinit sur une struct. Marquez la méthode de terminaison consuming pour que le compilateur prouve qu'il s'agit de la dernière utilisation. La propriété des paramètres devient explicite : borrowing (lecture seule, par défaut), consuming (prend possession), inout/mutating (accès temporaire en écriture).


2. Erreurs et optionnels — rendez les chemins d'échec visibles

La gestion des erreurs en Swift repose sur trois points : les sources d'erreur sont marquées afin qu'elles ne puissent pas vous surprendre ; les erreurs portent suffisamment de contexte pour agir ; et les erreurs récupérables sont différentes des erreurs de programmation.

  • Récupérable → throw. Erreur de programmation → precondition/fatalError. Un appel réseau échoué maintient le programme en vie. Un index hors limites signifie que le code est erroné et doit s'arrêter avant que le bogue ne devienne un problème de sécurité.
  • Les enums avec valeurs associées constituent les meilleurs types d'erreur. cas amiDoublon(Chaîne) bat cas amiDoublon — le contexte est tout l'intérêt.
  • guard pour les conditions d'erreur, car il force la sortie. if let pour le déballage ordinaire.
  • throws(MonErreur) typé est pour les fonctions internes, le code générique qui transmet des erreurs, et les environnements contraints où l'encapsulation dans any Error est trop coûteuse. Pour l'API publique, throws non typé préserve votre liberté de changer le type d'erreur plus tard. Notez l'unification : throws est throws(any Error), et ne pas lever est throws(Never) — ce qui permet à map de faire abstraction des deux.
  • Force-unwrap seulement là où vous pouvez énoncer l'invariant, et préférez un #require/precondition avec un message plutôt qu'un ! nu.

3. Concurrence : restez mono-thread jusqu'à ce que le profilage dise le contraire

C'est la section que les agents comprennent le plus souvent de travers, car le modèle a changé dans Swift 6.2.

Démarrez chaque application entièrement sur le thread principal. Le code mono-thread va loin, et la plupart des applications n'ont jamais besoin de le quitter.

La progression, dans l'ordre. Ne sautez pas les étapes.

  1. Mono-thread sur l'acteur principal. Pas de concurrence du tout. Bon pour la plupart des applications.
  2. async/await pour masquer la latence (réseau, disque). Toujours pas de concurrence de votre propre chef — les API du SDK comme URLSession.data(from:) déchargent pour vous.
  3. @concurrent pour déplacer votre travail coûteux hors du thread principal — seulement après qu'Instruments montre un blocage.
  4. actor pour déplacer l'état hors de l'acteur principal — seulement lorsque trop d'état sur l'acteur principal force les tâches à revenir constamment.

Activez d'abord les bons paramètres de build. Activez Concurrence Abordable dans chaque projet. Pour les modules d'application et les modules d'interface utilisateur, définissez également Isolement par Défaut de l'Acteur sur ActeurPrincipal — c'est la valeur par défaut pour les nouveaux projets d'application dans Xcode 26, et cela supprime la plupart de vos annotations @MainActor. Dans un package : swiftSettings: [.defaultIsolation(MainActor.self)]. Ne définissez pas main-actor-by-default pour une bibliothèque à usage général — les bibliothèques devraient fournir des API nonisolated et laisser les clients décider où le travail s'exécute.

La règle qui a changé

Dans Swift 6.2, marquer une fonction async ne la déplace pas de l'acteur courant. Elle s'exécute là d'où elle a été appelée. C'est ce qui rend « le code le plus naturel à écrire » sans course de données par défaut.

  • @concurrent — bascule toujours vers le pool de threads concurrents. Utilisez-le pour votre travail intensif en calcul.
  • nonisolated — s'exécute là d'où il est appelé. C'est la valeur par défaut correcte pour les API de bibliothèque, car l'appelant décide. nonisolated sur un type rend tous ses membres nonisolés (Swift 6.1+).
  • Ni l'un ni l'autre — reste sur l'acteur de l'appelant.
nonisolated struct ProcesseurPhoto {          // découplé de l'acteur principal
  @concurrent                                // garanti de s'exécuter en arrière-plan
  func traiter(_ donnees: Donnees) async -> PhotoTraitee {
    async let autocollant = extraireAutocollant(donnees)  // deux tâches indépendantes, en parallèle
    async let couleurs  = extraireCouleurs(donnees)
    return await PhotoTraitee(autocollant: autocollant, couleurs: couleurs)
  }
}
  • Profilez avant de décharger. Utilisez Instruments (Time Profiler, blocages). Si le code peut être accéléré sans concurrence, faites toujours cela en premier. La concurrence a un coût réel — allocation de tâche, ordonnancement et raisonnement.
  • Ne créez pas de tâche pour un travail trivial. Une tâche enfant pour lire une valeur UserDefaults coûte plus qu'elle n'en sauve.
  • Une tâche par opération de bout en bout. Le travail qui doit se produire dans l'ordre va dans une tâche ; les opérations indépendantes obtiennent des tâches séparées pour que l'exécution puisse les entrelacer.
  • await est un point de suspension, et il brise l'atomicité. L'état peut changer pendant que vous êtes suspendu, et vous pouvez reprendre sur un thread différent. Revérifiez les hypothèses après chaque await. Ne tenez jamais un verrou à travers un. Ne comptez jamais sur le stockage local du thread à travers un.

Réentrance des acteurs

Les acteurs garantissent l'exclusion mutuelle, pas les transactions. Entre deux await sur le même acteur, d'autres travaux s'exécutent.

  • Mutez l'état de l'acteur dans des méthodes synchrones. Le code synchrone sur un acteur s'exécute jusqu'à son terme sans interruption — c'est votre limite de transaction.
  • Gardez les méthodes asynchrones des acteurs légères, composées d'opérations transactionnelles synchrones, et laissez l'acteur dans un état cohérent à chaque await.
  • Le bogue classique : vérifier le cache → await télécharger → écrire le cache. Deux tâches échouent toutes deux au cache, téléchargent toutes deux, la seconde écrase la première. Revérifiez après le await, ou dédupliquez le travail en cours.
  • Les acteurs ne sont pas FIFO. Ils exécutent d'abord le travail de plus haute priorité, précisément pour éviter l'inversion de priorité. Si vous avez besoin d'ordonnancement, utilisez une tâche (qui s'exécute du début à la fin) ou un AsyncStream, pas un acteur.

4. Sendable et partage de données

Sendable marque un type comme sûr à partager entre domaines d'isolement. Le compilateur le vérifie à chaque frontière de tâche et d'acteur.

  • Les types valeur sont Sendable lorsque leur stockage l'est — inféré automatiquement pour les types non publics. Les types publics n'ont jamais d'envoi inféré : marquer un type public Sendable est une promesse à vos clients, donc Swift vous oblige à l'écrire.
  • Les acteurs et les classes @MainActor sont implicitement Sendable, car leur état est isolé.
  • La plupart des classes de modèle ne devraient être ni @MainActor ni Sendable. Gardez-les non-Sendable intentionnellement — cela empêche la moitié du modèle d'être mutée sur le thread principal tandis que l'autre moitié est mutée en arrière-plan. Si elles doivent quitter l'acteur principal, rendez-les nonisolated, pas Sendable.
  • Vous pouvez toujours envoyer un objet non-Sendable entre domaines tant que l'expéditeur cesse de l'utiliser. Effectuez toutes vos mutations avant de le transmettre ; y toucher après est l'erreur.
  • Les fermetures capturent aussi l'état. Ne marquez un type de fonction @Sendable que s'il traverse vraiment les domaines.
  • @unchecked Sendable est une promesse que le compilateur ne peut pas vérifier. Réservez-le pour les types avec une véritable synchronisation interne (un Mutex, un verrou). Idem pour nonisolated(unsafe) sur un global — dernier recours, pas un silencieux d'avertissement.

Lorsque vous rencontrez une erreur de course de données, parcourez cette liste :

  1. Ne le partagez pas. Déplacez l'objet partagé dans une variable locale afin que chaque tâche concurrente obtienne sa propre instance. (C'est la correction pour la grande majorité des erreurs réelles.)
  2. Transformez-le en un type valeur Sendable, de sorte que « partager » soit vraiment copier.
  3. Isolez-le dans un acteur — l'acteur principal, ou le vôtre.
  4. Alors seulement, utilisez Mutex/Atomic du module Synchronization (stockez-les dans des propriétés let), ou @unchecked Sendable.

Les variables globales et statiques sont la source la plus courante d'erreurs. Par ordre de préférence : faites-en un let ; mettez-le sur @MainActor ; encapsulez-le dans un Mutex ; nonisolated(unsafe). Notez que les globales en Swift sont initialisées paresseusement et atomiquement — contrairement au C.

Bridging des anciennes API de rappel : annotez les protocoles délégués avec @MainActor si vous les possédez. Si ce n'est pas le cas, marquez la méthode nonisolated et utilisez MainActor.assumeIsolated { } — cela affirme plutôt que de sauter, donc cela piège bruyamment au lieu de courir en silence. @preconcurrency sur la conformité est le raccourci pour la même chose. Utilisez @preconcurrency import pour faire taire temporairement les avertissements d'envoi d'un module qui n'a pas migré ; les avertissements reviennent — correctement — une fois qu'il l'a fait.


5. Concurrence structurée

Préférez toujours les tâches structurées.

Les tâches structurées (async let, groupes de tâches) sont limitées comme les variables locales : elles ne peuvent pas survivre au bloc, elles sont attendues automatiquement, et elles héritent de l'annulation, de la priorité et des valeurs locales à la tâche à travers l'arbre de tâches. Les tâches non structurées (Task { }, Task.detached) ne vous donnent rien de tout cela automatiquement.

  • async let pour un nombre fixe et statiquement connu d'enfants concurrents.
  • withTaskGroup lorsque le nombre est dynamique. Les groupes de tâches sont conformes à AsyncSequence — itérez les résultats au fur et à mesure qu'ils arrivent. Utilisez withDiscardingTaskGroup lorsque les enfants ne retournent rien : cela libère les ressources de chaque enfant immédiatement et annule les frères et sœurs à la première erreur.
  • Task { } uniquement lorsque la durée de vie du travail ne correspond pas à une portée — réagir à un rappel de délégué, un clic sur un bouton, une vue qui apparaît. Il hérite de l'isolement et de la priorité de l'acteur ; vous devez gérer l'annulation vous-même.
  • Task.detached presque jamais. Il n'hérite de rien — ni isolement, ni priorité, ni variables locales de tâche. Si vous avez besoin d'une racine détachée, mettez un groupe de tâches à l'intérieur plutôt que de détacher à plusieurs reprises.

L'annulation est coopérative. Annuler définit un drapeau ; cela n'arrête rien. Vérifiez Task.isCancelled ou try Task.checkCancellation() avant de commencer un travail coûteux, et aussi dans les aides synchrones. Pour un travail qui est suspendu plutôt qu'en cours d'exécution (le next() d'un AsyncSequence), utilisez withTaskCancellationHandler — et rappelez-vous que le gestionnaire s'exécute immédiatement et concurrentiellement au corps, donc l'état qu'il touche a besoin d'une véritable synchronisation (un atomique ou un verrou, pas un acteur — vous ne pouvez pas garantir l'ordre sur un acteur).

Limitez votre concurrence. Ne répartissez pas un enfant par élément sur une liste non bornée. Démarrez N enfants, puis ajoutez-en un nouveau de plus.

Individual skills in this repo

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

CharbelElBateh/personal-website

Build animations in React Native and Expo, making the decisions in the order that determines whether they feel right — should it animate, which thread it runs on, which properties, spring or timing, how the gesture hands off, how it degrades. Writes the implementation with Reanimated, Gesture Handler, Expo Router and expo-haptics. Use when animating anything in an Expo app, adding gestures, sheets, screen transitions, press feedback or haptics, or fixing motion that stutters on device. For web animation use `animate`.

CharbelElBateh/personal-website

Build an animation from scratch, making the decisions in the order that determines whether it feels right — should it animate at all, what purpose, which tool, which properties, which curve and duration, how it interrupts, how it exits. Writes the implementation. Use when asked to animate something, add motion, make a component feel alive, or build a transition. For critiquing existing motion use review-animations; for auditing a whole codebase use improve-animations.

CharbelElBateh/personal-website

Reverse-lookup glossary that turns a vague description of a web animation or motion effect into its exact term ("the bouncy thing when a popover opens" → Pop in; "the iOS rubber-band scroll" → Rubber-banding). Use when the user asks "what's it called when…", or describes a motion effect without knowing its name and wants the right word to prompt an AI or designer with. For naming an effect, not designing or building one.

CharbelElBateh/personal-website

Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.

CharbelElBateh/personal-website

Guide to Sonner, the React toast library — install and wire up the Toaster, pick the right toast() call, promise and loading toasts, updating, dismissing and persisting toasts, styling, theming and icons, positioning and multiple toasters. Use when working with Sonner or troubleshooting it — toasts that don't appear, appear twice, lose their styles, ignore Tailwind classes, sit behind a modal, or don't follow dark mode.

CharbelElBateh/personal-website

Try to break a piece of UI by feeding it worst-case data — long names, unbreakable emails, one-letter names, missing fields, huge counts, zero items, long labels, non-Latin text, emoji, extreme numbers — then render it behind a "Demo data / Worst case" toggle and report everything that broke, with the fix for each. Use when the user asks to stress-test, break, or find edge cases in a component or screen, or to "try the worst case". For visual design critique use emil-design-eng; for motion use review-animations.

CharbelElBateh/personal-website

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

CharbelElBateh/personal-website

Search a codebase or UI for places that don't animate but should, and reject everything that shouldn't. Read-only; it proposes motion with exact values, it does not implement it. Use when the user asks "what could be animated here?" or wants to "make this feel more alive". For fixing existing animations, use improve-animations or review-animations instead.

CharbelElBateh/personal-website

Survey a codebase's animation and motion code as a senior motion advisor, then produce a prioritized audit and self-contained implementation plans for other agents (or cheaper models) to execute. Read-only on source code — it plans improvements, it does not apply them. Use when the user asks to "improve the animations", "audit the motion", "make this app feel better", or wants a roadmap of animation fixes rather than a review of a single diff.

CharbelElBateh/personal-website

Make a web app feel native on a phone — the small CSS and meta-tag fixes that separate "a website in a browser" from something that feels installed. Covers sticky hover states, tap highlight flashes, the 100vh bug, inputs that zoom the page, laggy taps, pull-to-refresh hijacking scroll, content under the notch, long-press selecting button text, carousels that scroll the wrong way, mismatched status bars, and the rule that you test on real hardware. Use when a web app is being built for or reviewed on mobile, when something "works in Chrome but feels wrong on my phone", when building a PWA, a bottom sheet, a carousel, a full-screen layout, or any touch interaction. For motion itself use animate; for React Native use animate-expo.

CharbelElBateh/personal-website

Pick the right library for a given frontend task from a curated, opinionated list — numbers, OTP inputs, charts, command menus, virtualization, drag and drop, toasts, state, styling, and more. Only runs when explicitly invoked; it does not trigger on its own.

CharbelElBateh/personal-website

Build multiple genuinely different versions of a UI piece you describe, rendered behind a visual picker so you can flip through them live and promote the one that feels right. Only runs when explicitly invoked; it does not trigger on its own.

CharbelElBateh/personal-website

Reviews animation and motion code against a high craft bar derived from Emil Kowalski's design engineering philosophy. Default to flagging; approval is earned.

Skills associés