Communitygithub.com

CharbelElBateh/personal-website

Wie man modernes Swift schreibt – Modellierung mit Werttypen, Datenwettlauf-Sicherheit in Swift 6 und verständliche Nebenläufigkeit (@concurrent, Main-Actor-Standard, Akteure, Aufgaben-Gruppen), Protokolle und Generics (some vs any), API-Design, Leistung und ARC, Swift Testing, Makros und die modernen Sprachfunktionen, die Agenten noch nicht kennen. Verwenden beim Schreiben, Überprüfen oder Migrieren von Swift sowie bei der Behebung von Nebenläufigkeitsfehlern, Hängern, Datenwettläufen, Speicherzyklen oder Leistungsproblemen.

Was ist personal-website?

Dieses Skill beschreibt, wie man modernes Swift schreibt, so wie die Sprache geschrieben werden möchte, aktuell bis Swift 6.4. Es betont eine progressive Offenlegung von Sprachfeatures: Beginne mit dem einfachsten, statischsten und single-threaded Ansatz und füge Dynamik wie Nebenläufigkeit, Referenzsemantik oder unsichere Pointer nur dort hinzu, wo ein klarer Grund dafür spricht. Das Skill behandelt Modellierung mit Werttypen (struct/enum), die korrekte Verwendung von Nebenläufigkeit (async/await, @concurrent, Akteure) in Swift 6.2+, Sendable und Datenweitergabe, strukturierte Nebenläufigkeit, Protokolle und Generics (some/any), API-Design und Leistung, Arc und Speicherverwaltung, Swift Testing, Makros und moderne Sprachfeatures wie nicht kopierbare Typen und typisierte throws. Es unterstützt alle Swift-Entwickler, die plattformunabhängig modernen, sicheren und performanten Code schreiben möchten, und ist besonders nützlich für das Schreiben, Überprüfen oder Migrieren von Swift-Code sowie die Behebung von Nebenläufigkeitsfehlern, Hängern, Datenwettläufen, Speicherzyklen oder Leistungsproblemen.

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

In Ihrer bevorzugten KI fragen

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

Dokumentation

Swift schreiben

Erste Reaktion

Wenn dieses Skill zum ersten Mal ohne eine spezifische Frage aufgerufen wird, antworte nur mit:

Ich bin bereit, Ihnen zu helfen, modernes Swift zu schreiben, so wie die Sprache geschrieben werden möchte.

Gib erst dann weitere Informationen, wenn der Benutzer eine Frage stellt.

Wie man Swift so schreibt, wie die Sprache geschrieben werden möchte, aktuell bis Swift 6.4.

Toolchain-Basis: Swift 6.3 (aktuelle Version ab August 2026). Alles hier kompiliert mit 6.3, es sei denn, es ist mit ⚠ markiert, was auf noch nicht veröffentlichte Swift 6.4-Features hinweist. Die Nebenläufigkeitsrichtlinien gehen vom Swift 6.2-Modell aus – wenn das Projekt auf 6.1 oder älter ist, gelten die Regeln in §3 zu async und @concurrent nicht.

Der rote Faden: Swift ist eine Sprache mit progressiver Offenlegung. Beginne mit dem einfachsten, statischsten, am stärksten single-threaded Ansatz, der funktioniert, und kaufe Dynamik – Nebenläufigkeit, Referenzsemantik, Existentials, unsichere Pointer – nur dort, wo du einen Grund nennen kannst. Jede der folgenden Regeln ist eine Anwendung dieses Prinzips.

Modelliere diese Hierarchie von Standardwerten. Gehe nur dann eine Ebene tiefer, wenn du einen Grund nennen kannst:

BedarfGreife zuGehe tiefer nur, wenn
Datenstruct / enumdu Identität, gemeinsame Nutzung oder Vererbung benötigst
Abstraktionkonkreter Typdu wiederholten Code über Typen hinweg hast
Polymorphiesome P (generisch)du heterogene Speicherung benötigst → any P
AusführungHaupt-Actor, synchronProfiling einen Hänger zeigt → async → @concurrent → actor
SpeicherArray, StringProfiling die Kosten zeigt → InlineArray, Span
Sicherheitsicheres APIC-Interop oder ein gemessener Hot-Path → Unsafe*

1. Daten mit Werttypen modellieren

Werttypen sind in Swift der Standard, kein Sonderfall.

  • Standardmäßig struct und enum verwenden. class nur für Identität, gemeinsam genutzten veränderlichen Zustand, Vererbung oder Ressourcenlebensdauer. Ein Fenster, eine Datenbankverbindung, eine in einer Rendering-Engine gespeicherte Entität – diese haben Identität. Ein Punkt, ein Getränk, ein Material nicht.
  • let als Standard; var nur, wenn du mutierst. Dies ist die gleiche Disziplin wie some vor any und Wert vor Referenz: fange eng an, weite nur mit Grund.
  • Ein Struct mit einer veränderlichen Referenztyp-Eigenschaft ist weder ein Wert noch eine Referenz. Kopien teilen sich das Objekt; Mutationen wirken sich auf Kopien aus. Entweder den referenzierten Typ unveränderlich halten, nur berechnete Eigenschaften verfügbar machen, die an ihn weiterleiten, oder ihn als private gespeicherte Eigenschaft hinter Copy-on-Write machen.
  • Copy-on-Write ist, wie du außerhalb liegenden Speicher und Wertsemantik bekommst. Wickle eine final-Klasse in ein Struct ein und überprüfe isKnownUniquelyReferenced(&storage) vor dem Mutieren; kopiere zuerst, wenn nicht. Genau so funktionieren Array, String und Dictionary.
  • Enums sind das Werkzeug für „eine feste Menge von Dingen“ und für sich gegenseitig ausschließende Zustände. Das Ersetzen eines Haufens optionaler gespeicherter Eigenschaften (isSharing, selectedRows, shareTarget) durch einen einzigen enum State macht ungültige Kombinationen nicht darstellbar und macht Zustandsänderungen atomar statt einer Folge von Eigenschaftsschreibvorgängen, die man vergessen kann zu beenden.
  • Das Zusammensetzen von Werten ergibt einen Wert. Ein Struct, dessen gespeicherte Eigenschaften alle Werttypen sind, hat automatisch Wertsemantik – was Rückgängig, Differenzvergleiche und Zustandswiederherstellung zu einem einzigen Codepfad macht, statt zu einem pro Eigenschaft.
struct Material {                       // Wertsemantik erhalten
  var roughness: Double
  private var _texture: Texture         // eine Klasse

  var color: Color {
    get { _texture.color }
    set {
      if !isKnownUniquelyReferenced(&_texture) { _texture = Texture(copying: _texture) }
      _texture.color = newValue
    }
  }
}

Nicht kopierbare Typen (~Copyable) drücken eindeutigen Besitz aus: einen Dateideskriptor, eine Banküberweisung, eine offene Ressource. Das Unterdrücken der Kopie verwandelt „Du darfst dies nicht zweimal ausführen“ von einer Zusicherung in einen Kompilierungsfehler und macht deinit bei einem Struct sinnvoll. Markiere die abschließende Methode als consuming, damit der Compiler beweist, dass es die letzte Verwendung ist. Die Parameter-Eigentümerschaft wird explizit: borrowing (schreibgeschützt, der Standard), consuming (nimmt es weg), inout/mutating (temporärer Schreibzugriff).


2. Fehler und Optionals – Fehlerpfade sichtbar machen

Die Swift-Fehlerbehandlung basiert auf drei Punkten: Fehlerquellen sind markiert, sodass sie dich nicht überraschen können; Fehler tragen genügend Kontext, um darauf reagieren zu können; und behebbare Fehler unterscheiden sich von Programmierfehlern.

  • Behebbar → throw. Programmierfehler → precondition/fatalError. Ein fehlgeschlagener Netzwerkaufruf hält das Programm am Laufen. Ein Index außerhalb des gültigen Bereichs bedeutet, dass der Code falsch ist und anhalten muss, bevor der Fehler zu einem Sicherheitsproblem wird.
  • Enums mit assoziierten Werten sind die besten Fehlertypen. case duplicateFriend(String) ist besser als case duplicateFriend – der Kontext ist der springende Punkt.
  • guard für Fehlerbedingungen, weil es den Exit-Pfad erzwingt. if let für das normale Entpacken.
  • Typisierte Würfe (throws(MyError)) sind für interne Funktionen, fehlerweiterleitenden generischen Code und eingeschränkte Umgebungen, wo das Einpacken von any Error zu teuer ist. Für öffentliche APIs bewahrt untypisiertes throws deine Flexibilität, den Fehlertyp später zu ändern. Beachte die Vereinheitlichung: throws ist throws(any Error), und nicht-werfend ist throws(Never) – was es map ermöglicht, über beide zu abstrahieren.
  • Entpacken mit Gewalt nur, wenn du die Invariante angeben kannst, und bevorzuge ein fehlschlagendes #require/precondition mit einer Nachricht gegenüber einem bloßen !.

3. Nebenläufigkeit: Bleibe einfach threaded, bis Profiling etwas anderes sagt

Dies ist der Abschnitt, den Agenten am häufigsten falsch verstehen, weil sich das Modell in Swift 6.2 geändert hat.

Starte jede App vollständig auf dem Hauptthread. Einfach threaded Code reicht weit, und die meisten Apps müssen ihn nie verlassen.

Der Fortschritt, in der Reihenfolge. Überspringe keine Schritte.

  1. Einfach threaded auf dem Haupt-Actor. Keine Nebenläufigkeit. Für die meisten Apps ausreichend.
  2. async/await, um Latenz zu verbergen (Netzwerk, Festplatte). Noch immer keine eigene Nebenläufigkeit – SDK-APIs wie URLSession.data(from:) lagern für dich aus.
  3. @concurrent, um deine teure Arbeit vom Hauptthread zu verschieben – nur, nachdem Instruments einen Hänger gezeigt hat.
  4. actor, um Zustand vom Haupt-Actor zu verschieben – nur, wenn zu viel Haupt-Actor-Zustand Tasks ständig zurückhüpfen lässt.

Aktiviere zuerst die richtigen Baueinstellungen. Aktiviere Verständliche Nebenläufigkeit in jedem Projekt. Für App-Module und UI-Module setze zusätzlich Standard-Actor-Isolation auf MainActor – es ist der Standard für neue App-Projekte in Xcode 26 und es löscht die meisten deiner @MainActor-Annotationen. In einem Paket: swiftSettings: [.defaultIsolation(MainActor.self)]. Setze Main-Actor-Standard nicht für eine Allzweckbibliothek – Bibliotheken sollten nonisolated-APIs ausliefern und Clients entscheiden lassen, wo Arbeit läuft.

Die Regel, die sich geändert hat

In Swift 6.2 verschiebt das Markieren einer Funktion als async sie nicht vom aktuellen Actor. Sie läuft dort, wo sie aufgerufen wurde. Das macht „den natürlichsten zu schreibenden Code“ standardmäßig datenwettlauffrei.

  • @concurrent – wechselt immer zum gleichzeitigen Thread-Pool. Verwende es für deine CPU-intensive Arbeit.
  • nonisolated – läuft, wo immer sie aufgerufen wird. Dies ist die richtige Voreinstellung für Bibliotheks-APIs, weil der Aufrufer entscheidet. nonisolated bei einem Typ macht alle seine Member nonisolated (Swift 6.1+).
  • Keines von beiden – bleibt auf dem Actor des Aufrufers.
nonisolated struct PhotoProcessor {          // vom Haupt-Actor entkoppelt
  @concurrent                                // läuft garantiert im Hintergrund
  func process(_ data: Data) async -> ProcessedPhoto {
    async let sticker = extractSticker(data)  // zwei unabhängige Jobs, parallel
    async let colors  = extractColors(data)
    return await ProcessedPhoto(sticker: sticker, colors: colors)
  }
}
  • Profiling vor dem Auslagern. Verwende Instruments (Time Profiler, Hänger). Wenn der Code ohne Nebenläufigkeit schneller gemacht werden kann, mach das immer zuerst. Nebenläufigkeit hat echte Kosten – Task-Zuteilung, Planung und Nachdenken.
  • Erzeuge keinen Task für triviale Arbeit. Ein Kind-Task zum Lesen eines UserDefaults-Werts kostet mehr, als er spart.
  • Ein Task pro Ende-zu-Ende-Operation. Arbeit, die in der Reihenfolge stattfinden muss, gehört in einen Task; unabhängige Operationen erhalten separate Tasks, damit die Laufzeit sie verschränken kann.
  • await ist ein Suspendierungspunkt und bricht die Atomarität. Der Zustand kann sich während der Suspendierung ändern, und du kannst auf einem anderen Thread fortgesetzt werden. Überprüfe Annahmen nach jedem await. Halte niemals eine Sperre über ein await hinweg. Verlasse dich niemals auf Thread-lokalen Speicher über ein await hinweg.

Actor-Wiedereintritt

Actors garantieren gegenseitigen Ausschluss, keine Transaktionen. Zwischen zwei await desselben Actors läuft andere Arbeit.

  • Mutiere Actor-Zustand in synchronen Methoden. Synchroner Code auf einem Actor läuft ohne Unterbrechung zu Ende – das ist deine Transaktionsgrenze.
  • Halte asynchrone Actor-Methoden schlank, bestehend aus synchronen Transaktionsoperationen, und hinterlasse den Actor in einem konsistenten Zustand bei jedem await.
  • Der klassische Fehler: Cache prüfen → await Download → Cache schreiben. Zwei Tasks verfehlen beide, beide laden herunter, der zweite überschreibt den ersten. Überprüfe nach dem await erneut oder dedupliziere die laufende Arbeit.
  • Actors sind nicht FIFO. Sie führen zuerst die Arbeit mit der höchsten Priorität aus, genau um Prioritätsumkehr zu vermeiden. Wenn du eine Reihenfolge benötigst, verwende einen Task (der von Anfang bis Ende läuft) oder einen AsyncStream, nicht einen Actor.

4. Sendable und gemeinsame Datennutzung

Sendable markiert einen Typ als sicher für die Weitergabe über Isolationsdomänen hinweg. Der Compiler prüft es an jeder Task- und Actor-Grenze.

  • Werttypen sind Sendable, wenn ihr Speicher es ist – automatisch abgeleitet für nicht-öffentliche Typen. Öffentliche Typen erhalten niemals abgeleitete Sendability: Das Markieren eines öffentlichen Typs als Sendable ist ein Versprechen an deine Clients, also zwingt Swift dich, es zu schreiben.
  • Actors und @MainActor-Klassen sind implizit Sendable, weil ihr Zustand isoliert ist.
  • Die meisten Modellklassen sollten weder @MainActor noch Sendable sein. Behalte sie absichtlich nicht-Sendable – das verhindert, dass die Hälfte des Modells auf dem Hauptthread mutiert wird, während die andere Hälfte im Hintergrund mutiert wird. Wenn sie den Haupt-Actor verlassen müssen, mach sie zu nonisolated, nicht zu Sendable.
  • Du kannst dennoch ein nicht-Sendable-Objekt zwischen Domänen senden, solange der Sender es nicht mehr verwendet. Mache alle Mutationen vor der Übergabe; es danach zu berühren ist der Fehler.
  • Closures fangen ebenfalls Zustand ein. Markiere einen Funktionstyp nur dann als @Sendable, wenn er wirklich Domänen kreuzt.
  • @unchecked Sendable ist ein Versprechen, das der Compiler nicht prüfen kann. Hebe es für Typen mit echter interner Synchronisation (ein Mutex, eine Sperre) auf. Gleiches gilt für nonisolated(unsafe) bei einer Globalen – letzte Möglichkeit, kein Warnungsunterdrücker.

Wenn du auf einen Datenwettlauffehler stößt, arbeite diese Liste ab:

  1. Teile es nicht. Verschiebe das geteilte Objekt in eine Lokale, sodass jeder gleichzeitige Job seine eigene Instanz erhält. (Dies ist die Lösung für die überwältigende Mehrheit der echten Fehler.)
  2. Mache es zu einem Sendable-Werttyp, sodass „Teilen“ wirklich Kopieren ist.
  3. Isoliere es zu einem Actor – dem Haupt-Actor oder deinem eigenen.
  4. Greife erst dann zu Mutex/Atomic aus dem Synchronization-Modul (speichere sie in let-Eigenschaften) oder zu @unchecked Sendable.

Globale und statische Variablen sind die häufigste Fehlerquelle. In der Reihenfolge der Präferenz: mache es zu einem let; setze es auf @MainActor; wickle es in ein Mutex; nonisolated(unsafe). Beachte, dass Globale in Swift faul und atomar initialisiert werden – anders als in C.

Überbrückung alter Callback-APIs: Annotiere Delegatenprotokolle mit @MainActor, wenn du sie besitzt. Wenn nicht, markiere die Methode als nonisolated und verwende MainActor.assumeIsolated { } – es setzt voraus, anstatt zu hüpfen, sodass es laut abbricht, anstatt leise zu konkurrieren. @preconcurrency auf der Konformität ist die Kurzform für dasselbe. Verwende @preconcurrency import, um Sendability-Warnungen von einem Modul, das noch nicht migriert wurde, vorübergehend zu unterdrücken; die Warnungen kommen zurück – korrekterweise – sobald es migriert ist.


5. Strukturierte Nebenläufigkeit

Bevorzuge immer strukturierte Tasks.

Strukturierte Tasks (async let, Task-Gruppen) sind wie lokale Variablen bereichsgebunden: Sie können den Block nicht überleben, werden automatisch erwartet, und sie erben durch den Task-Baum Absagen, Priorität und Task-lokale Werte. Unstrukturierte Tasks (Task { }, Task.detached) geben dir nichts davon automatisch.

  • async let für eine feste, statisch bekannte Anzahl gleichzeitiger Kinder.
  • withTaskGroup, wenn die Anzahl dynamisch ist. Task-Gruppen entsprechen AsyncSequence – iteriere die Ergebnisse, sobald sie eintreffen. Verwende withDiscardingTaskGroup, wenn Kinder nichts zurückgeben: Es gibt die Ressourcen jedes Kindes sofort frei und bricht Geschwister beim ersten Fehler ab.
  • Task { } nur, wenn die Lebensdauer der Arbeit nicht in einen Bereich passt – Reaktion auf einen Delegaten-Callback, einen Tastendruck, das Erscheinen einer View. Es erbt Actor-Isolation und Priorität; du musst die Absage selbst verwalten.
  • Task.detached fast nie. Es erbt nichts – keine Isolation, keine Priorität, keine Task-Lokalen. Wenn du eine abgetrennte Wurzel benötigst, setze eine Task-Gruppe innerhalb davon, anstatt wiederholt abzutrennen.

Absage ist kooperativ. Absagen setzt ein Flag; es stoppt nichts. Überprüfe Task.isCancelled oder try Task.checkCancellation() vor dem Start teurer Arbeit, und auch in synchronen Helfern. Für Arbeit, die eher ausgesetzt als läuft (das next() eines AsyncSequence), verwende withTaskCancellationHandler – und denke daran, dass der Handler sofort und gleichzeitig mit dem Körper läuft, sodass der Zustand, den er berührt, echte Synchronisation benötigt (ein Atomic oder eine Sperre, keine Actor – du kannst die Reihenfolge auf einem Actor nicht garantieren).

Begrenze deine Nebenläufigkeit. Verteile nicht ein Kind pro Element über eine unbegrenzte Liste. Starte N Kinder und füge dann ein weiteres hinzu, wenn ein vorheriges abgeschlossen ist. N sollte nicht größer sein als (Anzahl der CPU-Kerne) × 2 für CPU-gebundene Arbeit und nicht kleiner als die Anzahl der erwarteten gleichzeitigen E/A-Vorgänge (4-8 für Netzwerkaufrufe). withTaskGroup akzeptiert eine maxConcurrency-Einschränkung – verwende sie.

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.

Verwandte Skills