Communitygithub.com

ComeOnOliver/skillshub

Verwenden Sie dies, um Apps zu lokalisieren, String-Kataloge zu verwenden, typsichere Symbole zu generieren (Xcode 26+), mit Pluralformen, RTL-Layouts, gebietsschemaabhängiger Formatierung umzugehen oder von .strings-Dateien zu migrieren – umfassende i18n-Muster für Xcode 15-26.

Was ist skillshub?

Diese Fähigkeit bietet eine umfassende Anleitung zur Lokalisierung und Internationalisierung von iOS- und macOS-Apps mithilfe von String-Katalogen (`.xcstrings`), die ab Xcode 15 verfügbar sind, und löst ältere `.strings`- und `.stringsdict`-Formate ab. Sie behandelt die Einrichtung von String-Katalogen, die Verwendung von SwiftUI- und UIKit-Lokalisierungs-APIs, den korrekten Umgang mit Pluralformen (wichtig für Sprachen mit komplexen Pluralregeln), die Unterstützung von RTL-Sprachen (Rechts-nach-Links, z.B. Arabisch, Hebräisch) und gebietsschemaabhängige Formatierung von Daten, Zahlen und Währungen. Die Fähigkeit unterstützt Entwickler beim Erstellen vollständig lokalisierter Apps, die auf verschiedenen Plattformen (iOS, macOS, watchOS) laufen, und bietet Migrationsstrategien von älteren Formaten. Sie basiert auf den SKILL.md-Dokumenten und enthält Best Practices für Kommentare in Übersetzungen, semantische Layout-Richtungen und das Testen mit Pseudosprachen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-localization

In Ihrer bevorzugten KI fragen

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

Dokumentation

Lokalisierung & Internationalisierung

Umfassender Leitfaden zur App-Lokalisierung mit String-Katalogen. Apple Design Award Inclusivity-Gewinner unterstützen immer mehrere Sprachen mit hervorragender RTL-Unterstützung (Rechts-nach-Links).

Überblick

String-Kataloge (.xcstrings) sind Xcode 15s einheitliches Format zur Verwaltung der App-Lokalisierung. Sie ersetzen ältere .strings- und .stringsdict-Dateien mit einem einzigen JSON-basierten Format, das einfacher zu warten, zu diffen und in Übersetzungsabläufe zu integrieren ist.

Diese Fähigkeit behandelt String-Kataloge, SwiftUI/UIKit-Lokalisierungs-APIs, Plural-Handling, RTL-Unterstützung, gebietsschemaabhängige Formatierung und Migrationsstrategien von älteren Formaten.

Wann Sie diese Fähigkeit verwenden sollten

  • Einrichten von String-Katalogen in Xcode 15+
  • Lokalisieren von SwiftUI- und UIKit-Apps
  • Korrekte Handhabung von Pluralformen (kritisch für viele Sprachen)
  • Unterstützung von RTL-Sprachen (Arabisch, Hebräisch)
  • Formatieren von Daten, Zahlen und Währungen nach Gebietsschema
  • Migrieren von älteren .strings/.stringsdict-Dateien
  • Vorbereiten von App-Verknüpfungen und App Intents für die Lokalisierung
  • Debuggen fehlender Übersetzungen oder falscher Pluralformen

Systemanforderungen

  • Xcode 15+ für String-Kataloge (.xcstrings)
  • Xcode 26+ für automatische Symbolgenerierung, #bundle-Makro und KI-gestützte Kommentargenerierung
  • iOS 15+ für LocalizedStringResource
  • iOS 16+ für App-Verknüpfungslokalisierung
  • Frühere iOS-Versionen verwenden ältere .strings-Dateien

Teil 1: String-Kataloge (WWDC 2023/10155)

Erstellen eines String-Katalogs

Methode 1: Xcode-Navigator

  1. Datei → Neu → Datei
  2. „String Catalog“ wählen
  3. Benennen (z.B. Localizable.xcstrings)
  4. Zum Ziel hinzufügen

Methode 2: Automatische Extraktion

Xcode 15 kann Zeichenfolgen automatisch extrahieren aus:

  • SwiftUI-Ansichten (Zeichenfolgenliterale in Text, Label, Button)
  • Swift-Code (String(localized:))
  • Objective-C (NSLocalizedString)
  • C (CFCopyLocalizedString)
  • Interface Builder-Dateien (.storyboard, .xib)
  • Info.plist-Werte
  • App-Verknüpfungsphrasen

Erforderliche Buildeinstellungen:

  • „Compiler zum Extrahieren von Swift-Zeichenfolgen verwenden“ → Ja
  • „Lokalisierung bevorzugt String-Kataloge“ → Ja

String-Katalog-Struktur

Jeder Eintrag hat:

  • Schlüssel: Eindeutige Kennung (standardmäßig der englische Text)
  • Standardwert: Fallback, wenn Übersetzung fehlt
  • Kommentar: Kontext für Übersetzer
  • Zeichenfolgentabelle: Organisation des Containers (Standard: „Localizable“)

Beispiel .xcstrings JSON:

{
  "sourceLanguage" : "en",
  "strings" : {
    "Danke fürs Einkaufen bei uns!" : {
      "comment" : "Label über dem Checkout-Button",
      "localizations" : {
        "en" : {
          "stringUnit" : {
            "state" : "translated",
            "value" : "Thanks for shopping with us!"
          }
        },
        "es" : {
          "stringUnit" : {
            "state" : "translated",
            "value" : "¡Gracias por comprar con nosotros!"
          }
        }
      }
    }
  },
  "version" : "1.0"
}

Übersetzungsstatus

Xcode verfolgt den Status jeder Übersetzung:

  • Neu (⚪) – Zeichenfolge wurde noch nicht übersetzt
  • Benötigt Überprüfung (🟡) – Quelle geändert, Übersetzung möglicherweise veraltet
  • Überprüft (✅) – Übersetzung genehmigt und aktuell
  • Veraltet (🔴) – Zeichenfolge nicht mehr im Quellcode gefunden

Arbeitsablauf:

  1. Entwickler fügt Zeichenfolge hinzu → Neu
  2. Übersetzer fügt Übersetzung hinzu → Überprüft
  3. Entwickler ändert Quelle → Benötigt Überprüfung
  4. Übersetzer aktualisiert → Überprüft
  5. Entwickler entfernt Code → Veraltet

Teil 2: SwiftUI-Lokalisierung

LocalizedStringKey (Automatisch)

SwiftUI-Ansichten mit String-Parametern unterstützen automatisch die Lokalisierung:

// ✅ Automatisch lokalisierbar
Text("Willkommen zur WWDC!")
Label("Danke fürs Einkaufen bei uns!", systemImage: "bag")
Button("Zur Kasse") { }

// Xcode extrahiert diese Zeichenfolgen in den String-Katalog

Wie es funktioniert: SwiftUI verwendet intern LocalizedStringKey, das Zeichenfolgen in String-Katalogen nachschlägt.

String(localized:) mit Kommentaren

Für explizite Lokalisierung in Swift-Code:

// Basis
let title = String(localized: "Willkommen zur WWDC!")

// Mit Kommentar für Übersetzer
let title = String(localized: "Willkommen zur WWDC!",
                   comment: "Titel des Benachrichtigungsbanners")

// Mit benutzerdefinierter Tabelle
let title = String(localized: "Willkommen zur WWDC!",
                   table: "WWDCNotifications",
                   comment: "Titel des Benachrichtigungsbanners")

// Mit Standardwert (Schlüssel ≠ englischer Text)
let title = String(localized: "WWDC_NOTIFICATION_TITLE",
                   defaultValue: "Willkommen zur WWDC!",
                   comment: "Titel des Benachrichtigungsbanners")

Bewährte Vorgehensweise: Fügen Sie immer comment hinzu, um Übersetzern Kontext zu geben.

LocalizedStringResource (Verzögerte Lokalisierung)

Zum Übergeben lokalisierbarer Zeichenfolgen an andere Funktionen:

import Foundation

struct CardView: View {
    let title: LocalizedStringResource
    let subtitle: LocalizedStringResource

    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 10.0)
            VStack {
                Text(title)      // Zur Renderzeit aufgelöst
                Text(subtitle)
            }
            .padding()
        }
    }
}

// Verwendung
CardView(
    title: "Letzte Einkäufe",
    subtitle: "Artikel, die Sie in der letzten Woche bestellt haben."
)

Hauptunterschied: LocalizedStringResource verschiebt die Suche bis zur Verwendung, sodass benutzerdefinierte Ansichten vollständig lokalisierbar sind.

AttributedString mit Markdown

// Markdown-Formatierung bleibt über Lokalisierungen hinweg erhalten
let subtitle = AttributedString(localized: "**Fetter** und _kursiver_ Text")

Teil 3: UIKit & Foundation

NSLocalizedString-Makro

// Basis
let title = NSLocalizedString("Letzte Einkäufe", comment: "Button-Titel")

// Mit Tabelle
let title = NSLocalizedString("Letzte Einkäufe",
                             tableName: "Einkaufen",
                             comment: "Button-Titel")

// Mit Bundle
let title = NSLocalizedString("Letzte Einkäufe",
                             tableName: nil,
                             bundle: .main,
                             value: "",
                             comment: "Button-Titel")

Bundle.localizedString

let customBundle = Bundle(for: MyFramework.self)
let text = customBundle.localizedString(forKey: "Willkommen",
                                        value: nil,
                                        table: "MyFramework")

Benutzerdefinierte Makros

// Objective-C
#define MyLocalizedString(key, comment) \
    [myBundle localizedStringForKey:key value:nil table:nil]

Info.plist-Lokalisierung

App-Namen, Berechtigungen usw. lokalisieren:

  1. Info.plist auswählen
  2. Editor → Lokalisierung hinzufügen
  3. InfoPlist.strings für jede Sprache erstellen:
// InfoPlist.strings (Spanisch)
"CFBundleName" = "Mi Aplicación";
"NSCameraUsageDescription" = "La app necesita acceso a la cámara para tomar fotos.";

Teil 4: Pluralisierung

Verschiedene Sprachen haben unterschiedliche Pluralregeln:

  • Englisch: 2 Formen (one, other)
  • Russisch: 3 Formen (one, few, many)
  • Polnisch: 3 Formen (one, few, other)
  • Arabisch: 6 Formen (zero, one, two, few, many, other)

SwiftUI Plural-Handling

// Xcode erstellt automatisch Plural-Varianten
Text("\(count) Artikel")

// Mit benutzerdefinierter Formatierung
Text("\(visitorCount) Aktuelle Besucher")

Im String-Katalog:

{
  "strings" : {
    "%lld Aktuelle Besucher" : {
      "localizations" : {
        "en" : {
          "variations" : {
            "plural" : {
              "one" : {
                "stringUnit" : {
                  "state" : "translated",
                  "value" : "%lld Aktueller Besucher"
                }
              },
              "other" : {
                "stringUnit" : {
                  "state" : "translated",
                  "value" : "%lld Aktuelle Besucher"
                }
              }
            }
          }
        }
      }
    }
  }
}

XLIFF-Exportformat

Beim Exportieren für die Übersetzung (Datei → Lokalisierungen exportieren):

Legacy (stringsdict):

<trans-unit id="/%lld Aktuelle Besucher:dict/NSStringLocalizedFormatKey:dict/:string">
    <source>%#@aktuellBesucher@</source>
</trans-unit>

<trans-unit id="/%lld Aktuelle Besucher:dict/aktuellBesucher:dict/one:dict/:string">
    <source>%lld Aktueller Besucher</source>
    <target>%lld Visitante Recente</target>
</trans-unit>

String-Katalog (sauberer):

<trans-unit id="%lld Aktuelle Besucher|==|plural.one">
    <source>%lld Aktueller Besucher</source>
    <target>%lld Visitante Recente</target>
</trans-unit>

<trans-unit id="%lld Aktuelle Besucher|==|plural.other">
    <source>%lld Aktuelle Besucher</source>
    <target>%lld Visitantes Recentes</target>
</trans-unit>

Substitutionen mit Plural-Variablen

// Mehrere Variablen mit unterschiedlichen Pluralformen
let message = String(localized: "\(songCount) Lieder auf \(albumCount) Alben")

Xcode erstellt Varianten für jede Variable der Pluralform:

  • songCount: one, other
  • albumCount: one, other
  • Gesamtkombinationen: 2 × 2 = 4 Übersetzungseinträge

Teil 5: Geräte- & Breiten-Varianten

Gerätespezifische Zeichenfolgen

Unterschiedlicher Text für verschiedene Plattformen:

// Gleicher Code, unterschiedliche Zeichenfolgen pro Gerät
Text("Vogelfutterladen")

String-Katalog-Varianten:

{
  "Vogelfutterladen" : {
    "localizations" : {
      "en" : {
        "variations" : {
          "device" : {
            "applewatch" : {
              "stringUnit" : {
                "value" : "Vogelfutter"
              }
            },
            "other" : {
              "stringUnit" : {
                "value" : "Vogelfutterladen"
              }
            }
          }
        }
      }
    }
  }
}

Ergebnis:

  • iPhone/iPad: „Vogelfutterladen"
  • Apple Watch: „Vogelfutter" (kürzer für kleinen Bildschirm)

Breiten-Varianten

Für dynamische Typ- und Größenklassen:

Text("Anwendungseinstellungen")

String-Katalog kann kürzeren Text für schmale Breiten bereitstellen.


Teil 6: RTL-Unterstützung

Layout-Spiegelung

SwiftUI spiegelt Layouts automatisch für RTL-Sprachen:

// ✅ Wird automatisch für Arabisch/Hebräisch gespiegelt
HStack {
    Image(systemName: "chevron.right")
    Text("Weiter")
}

// iPhone (Englisch): [>] Weiter
// iPhone (Arabisch):  Weiter [<]

Leading/Trailing vs. Left/Right

Verwenden Sie immer semantische Richtungen:

// ✅ Richtig – spiegelt automatisch
.padding(.leading, 16)
.frame(maxWidth: .infinity, alignment: .leading)

// ❌ Falsch – spiegelt nicht
.padding(.left, 16)
.frame(maxWidth: .infinity, alignment: .left)

Bilder und Symbole

Markieren Sie Bilder, die gespiegelt werden sollen oder nicht:

// ✅ Richtungsabhängig – spiegelt für RTL
Image(systemName: "chevron.forward")

// ✅ Nicht richtungsabhängig – spiegelt nie
Image(systemName: "star.fill")

// Benutzerdefinierte Bilder
Image("zurueckButton")
    .flipsForRightToLeftLayoutDirection(true)

Testen im RTL-Modus

Xcode-Schema:

  1. Schema bearbeiten → Ausführen → Optionen
  2. Anwendungssprache: Arabisch / Hebräisch
  3. ODER: App-Sprache → Rechts-nach-Links-Pseudosprache

Simulator: Einstellungen → Allgemein → Sprache & Region → Bevorzugte Sprachenreihenfolge

SwiftUI-Vorschau:

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
            .environment(\.layoutDirection, .rightToLeft)
            .environment(\.locale, Locale(identifier: "ar"))
    }
}

Teil 7: Gebietsschema-abhängige Formatierung

DateFormatter

let formatter = DateFormatter()
formatter.locale = Locale.current  // ✅ Aktuelles Gebietsschema verwenden
formatter.dateStyle = .long
formatter.timeStyle = .short

let dateString = formatter.string(from: Date())

// USA: "15. Januar 2024 um 15:30"
// Frankreich: "15 janvier 2024 à 15:30"
// Japan: "2024年1月15日 15:30"

Nie Datumsformatzeichenfolgen fest codieren:

// ❌ Falsch – bricht in anderen Gebietsschemata
formatter.dateFormat = "MM/dd/yyyy"

// ✅ Richtig – passt sich an Gebietsschema an
formatter.dateStyle = .short

NumberFormatter für Währung

let formatter = NumberFormatter()
formatter.locale = Locale.current
formatter.numberStyle = .currency

let priceString = formatter.string(from: 29.99)

// USA: "29,99 $" (Punkt als Dezimaltrenner, Dollarzeichen vor dem Betrag)
// UK: "£29.99"
// Japan: "¥30" (rundet auf ganze Zahl)
// Frankreich: "29,99 €" (Komma als Dezimaltrenner, Leerzeichen vor Symbol)

MeasurementFormatter

let distance = Measurement(value: 100, unit: UnitLength.meters)

let formatter = MeasurementFormatter()
formatter.locale = Locale.current

let distanceString = formatter.string(from: distance)

// USA: "328 ft" (konvertiert zu angloamerikanischem System)
// Metrische Länder: "100 m"

Gebietsschema-spezifische Sortierung

let names = ["Ångström", "Zebra", "Apple"]

// ✅ Gebietsschema-bewusste Sortierung
let sorted = names.sorted { (lhs, rhs) in
    lhs.localizedStandardCompare(rhs) == .orderedAscending
}

// Schweden: ["Ångström", "Apple", "Zebra"]  (Å kommt im Schwedischen zuerst)
// USA: ["Ångström", "Apple", "Zebra"]      (Å wird wie A behandelt)

Teil 8: Lokalisierung von App-Verknüpfungen

Phrasen mit Parametern

import AppIntents

struct ZeigeTopDonutsIntent: AppIntent {
    static var title: LocalizedStringResource = "Top-Donuts anzeigen"

    @Parameter(title: "Zeitraum")
    var zeitraum: Zeitraum

    static var parameterSummary: some ParameterSummary {
        Summary("\(.applicationName) Trends für \(\.$zeitraum)") {
            \.$zeitraum
        }
    }
}

String-Katalog extrahiert automatisch:

  • Intent-Titel
  • Parameternamen
  • Phrasenvorlagen mit Platzhaltern

Lokalisierte Phrasen:

Englisch: "Food Truck Trends for the last week"
Spanisch: "Tendencias de Food Truck para la última semana"

AppShortcutsProvider-Lokalisierung

struct FoodTruckShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: ZeigeTopDonutsIntent(),
            phrases: [
                "\(.applicationName) Trends für \(\.$zeitraum)",
                "Trending-Donuts anzeigen",
            ],
            shortTitle: "Donuts",
            systemImageName: "donut"
        )
    }
}

Wichtig: Ändern Sie keine Phrasenvorlagen in Xcode. Bearbeiten Sie den englischen Text, nicht die Vorlagen. Die Vorlagenstruktur muss in allen Lokalisierungen identisch sein.


Teil 9: Xcode 26+ Verbesserungen

Automatische Symbolgenerierung

Ab Xcode 26 generiert der Compiler automatisch type-sichere Symbole:

// Vor Xcode 26:
Text("Willkommen")
  .symbolVariants(.fill)

// Xcode 26+ (mit String-Katalog):
Text("Willkommen")
  .symbolVariants(.fill) // Automatisch typsicherer Aufruf

Vorteile:

  • Compiler-prüft lokalisierte Symbole
  • Weniger Laufzeitfehler
  • Bessere IDE-Vervollständigung

#bundle-Makro

// Verwenden Sie #bundle, um lokalisierbare Ressourcen zu kapseln
let meineApp = #bundle(
    name: "MeineApp",
    version: "1.0",
    localizationTable: "MeineAppUI"
)

// Greifen Sie auf lokalisierte Zeichenfolgen zu
Text("Hallo, Welt", bundle: meineApp)

KI-gestützte Kommentargenerierung

Xcode 26 kann automatisch Kontext für Zeichenfolgen generieren:

  1. String-Katalog öffnen
  2. Zeichenfolge auswählen → Rechtsklick → KI-Kommentar generieren
  3. Xcode analysiert die Verwendung und schlägt Kommentare vor

Beispiel:

Zeichenfolge: "Zur Kasse"
KI-Kommentar: "Zeigt den Warenkorb an, bevor die Zahlung abgeschlossen wird"

Teil 10: Migrationsstrategien

Migration von .strings

Manuelle Methode:

  1. Datei → Neu → String-Katalog
  2. Alte .strings-Dateien öffnen
  3. Schlüssel/Werte manuell in den Katalog kopieren
  4. Build-Lauf – Xcode warnt vor Duplikaten

Xcode-Migrationswerkzeug:

  1. Navigator → String-Katalogdatei auswählen
  2. Editor → Aus .strings-Dateien importieren
  3. Xcode gleicht Schlüssel ab und migriert Übersetzungen

Migration von Stringsdict

Die komplexere Migration erfordert:

  1. stringsdict kann nicht direkt importiert werden
  2. Neue Plural-Einträge im String-Katalog manuell erstellen
  3. Plural-Varianten aus stringsdict in die variations-Struktur kopieren

Schritte nach der Migration

  1. Alle Übersetzungen validieren: Keine New/Needs Review-Einträge
  2. Tests ausführen: Besonders Plural- und Formatierungstests
  3. Alte Dateien löschen: Nach Bestätigung der Vollständigkeit
  4. Build-Einstellungen aktualisieren:
    • LOCALIZATION_PREFERS_STRING_CATALOGS = YES
    • SWIFT_EMIT_LOC_STRINGS = YES

Fehlerbehebung

Häufige Probleme

Problem: Zeichenfolge wird nicht im Katalog angezeigt

  • Ursache: Statisch nicht extrahierbar (z.B. dynamischer Schlüssel)
  • Lösung: Manuell in den Katalog aufnehmen

Problem: Übersetzung wird nicht angewendet

  • Ursache: Falscher Tabellenname oder Bundle
  • Lösung: Überprüfen Sie, ob der Tabellenname zum Katalog passt

Problem: Pluralformen funktionieren nicht

  • Ursache: Variable ist kein Integer oder Ländercode falsch
  • Lösung: Verwenden Sie Int für Plural-Variablen und überprüfen Sie Gebietsschemata

Problem: RTL-Layout ist falsch

  • Ursache: Feste left/right-Werte in Layout/Constraints
  • Lösung: Auf leading/trailing umstellen und layoutDirection-Umgebung prüfen

Problem: Datumsformatierung zeigt falsche Lokalisierung

  • Ursache: Feste dateFormat-Zeichenfolge oder Locale nicht gesetzt
  • Lösung: dateStyle/timeStyle anstelle von dateFormat verwenden

Debugging-Tools

Xcode-Befehlszeile:

# Alle lokalisierbaren Zeichenfolgen in einem Projekt exportieren
xcodebuild -exportLocalizations -project App.xcodeproj -localizationPath ./Localizations

# Vorhandene Übersetzungen importieren
xcodebuild -importLocalizations -project App.xcodeproj -localizationPath ./Localizations/es.xliff

Swift-Pseudosprache (Xcode 15+):

// Fügen Sie dies zum String-Katalog hinzu, um Pseudosprache zu testen
// Bearbeiten → Pseudosprache → Doppelte Länge / RTL / Akzente

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

Verwandte Skills