Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

swiftui-engineering

/swiftui-engineering

Buduje, debuguje i poprawia natywne interfejsy SwiftUI: stan, nawigację, komponenty, dostępność i konwencje Apple.

Licencja
MIT
Ostatnia zmiana repozytorium
09.11.2026

Ocena i bezpieczeństwo

85/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 09.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Buduje, debuguje i poprawia natywne interfejsy SwiftUI: stan, nawigację, komponenty, dostępność i konwencje Apple.

Oryginalny opis (EN)

Build, debug, and refine native SwiftUI interfaces using declarative UI, state management, navigation, reusable components, accessibility, and modern Apple design conventions. Use when building, reviewing, refactoring, or debugging SwiftUI views and interfaces.

Jak działa

  1. Role
  2. Non-Negotiable Rules
  3. View Architecture
  4. State Management
  5. Navigation and Interaction
  6. Visual Design
  7. Accessibility
  8. Performance
  9. Verification
  10. Deliverables
Sekcje z nagłówków SKILL.md, w oryginale · 89 linii, 595 słów
Podgląd SKILL.md
---
name: swiftui-engineering
description: Build, debug, and refine native SwiftUI interfaces using declarative UI, state management, navigation, reusable components, accessibility, and modern Apple design conventions. Use when building, reviewing, refactoring, or debugging SwiftUI views and interfaces.
---

# SwiftUI Engineering Skill

## Role

Act as a senior SwiftUI engineer and interface architect. Build polished, responsive, accessible native Apple interfaces using SwiftUI.

## Non-Negotiable Rules

- Use SwiftUI for the UI unless the existing project explicitly requires UIKit or AppKit integration.
- Do not use React, React Native, HTML, CSS, or web views to imitate native interfaces.
- Prefer native Apple controls, layouts, navigation, materials, and system behaviors.
- Follow the project's deployment target and SDK availability.
- Use `#available` and appropriate fallbacks for APIs unavailable on supported OS versions.
- Never invent APIs or assume an API exists on the project's minimum OS.

## View Architecture

- Compose screens from small, reusable views.
- Keep body declarations readable and avoid monolithic views.
- Extract components when doing so improves clarity, reuse, or maintainability.
- Keep networking, persistence, and business logic outside view bodies.
- Use `@ViewBuilder` when it meaningfully simplifies composition.
- Prefer native layout tools such as `VStack`, `HStack`, `ZStack`, `Grid`, and `LazyVGrid`.
- Use `List` and lazy containers appropriately for larger collections.
- Avoid excessive nesting, unnecessary `GeometryReader` usage, and arbitrary hardcoded positioning.
- Respect safe areas, Dynamic Type, and different device sizes.

## State Management

Choose the appropriate mechanism for the project's Swift and OS versions.

- `@State` for local view-owned state.
- `@Binding` for state supplied by a parent.
- `@Observable` and `@State` for suitable modern observation architectures.
- `@Environment` for shared dependencies and environment values.
- `@StateObject` and `@ObservedObject` when using the Combine-based `ObservableObject` model.
- Avoid duplicate sources of truth.
- Avoid storing derived values as independent mutable state when they can be computed.
- Ensure asynchronous state updates respect actor isolation and cancellation.

## Navigation and Interaction

- Use `NavigationStack` and `NavigationSplitView` when supported by the deployment target.
- Prefer typed navigation routes for complex navigation flows.
- Handle loading, empty, success, and failure states explicitly.
- Use sheets, alerts, confirmation dialogs, and toolbars appropriately.
- Prevent duplicate submissions and unintended repeated actions.
- Preserve navigation state where appropriate.

## Visual Design

- Use consistent spacing, typography, corner radii, and visual hierarchy.
- Support Light Mode and Dark Mode unless the product intentionally specifies otherwise.
- Use system semantic colors by default; implement custom palettes when the design calls for them.
- Use SF Symbols when suitable.
- Use materials, gradients, animations, and transitions intentionally rather than decoratively everywhere.
- Keep animations responsive and respect Reduce Motion.
- Avoid layout hacks that break across device sizes.
- Do not replace an established design system without authorization.

## Accessibility

- Provide meaningful accessibility labels and hints where needed.
- Ensure interactive controls have usable hit targets.
- Support VoiceOver, Dynamic Type, and sufficient contrast.
- Do not communicate important status using color alone.
- Make custom controls accessible and keyboard-friendly where relevant.

## Performance

- Keep expensive work out of `body`.
- Avoid unnecessary view identity changes and state duplication.
- Use stable identifiers in `ForEach`.
- Avoid repeatedly creating expensive dependencies during view updates.
- Use Instruments or profiling tools when available before making performance claims.

## Verification

- Inspect existing views, models, navigation, and design conventions before editing.
- Build with the project's actual Xcode configuration when possible.
- Check previews and simulator behavior when available.
- Test interactions, state transitions, accessibility, and relevant OS variants.
- Never claim previews, builds, or simulator tests succeeded unless verified.

## Deliverables

Produce complete SwiftUI implementations integrated with the existing project. Preserve the app's identity and architecture, explain significant decisions, and list any verification that remains outstanding.
Pliki w paczce (4)
  • .gitignore 1 KB
  • LICENSE 1 KB
  • README.md 3 KB
  • SKILL.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · mshanghai570/swiftui-engineering-agent-skill-85MIT
apexbymanish/claude-ai-agents-ios90MIT

Migawka bazy z 13.11.2026 · wersja paczki 375183cb0059 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100ios-swiftui-declarative-ui
    Buduje natywne interfejsy iOS deklaratywnie w SwiftUI, z wiązaniem stanu, modyfikatorami widoków i stosami nawigacji.
  • 100swiftui-patterns
    Podpowiada wzorce architektury SwiftUI: stan przez Observable, kompozycję widoków, nawigację i wydajność renderowania w iOS i macOS.
  • 100swiftui-patterns
    Opisuje wzorce architektury SwiftUI: stan z @Observable, kompozycja widoków, nawigacja i optymalizacja wydajności renderowania w aplikacjach iOS i macOS.
  • 100swiftui
    Pilnuje wzorców SwiftUI przy pracy z AI: deklaratywnego UI, zarządzania stanem, Combine, nawigacji i dostępności.
  • 100ios-swiftui
    Buduje deklaratywne widoki SwiftUI i zarządza przepływem danych za pomocą property wrapperów w aplikacjach iOS.
  • 100swiftui-expert-skill
    Pisze, przegląda i poprawia kod SwiftUI: zarządzanie stanem, kompozycja widoków, wydajność i wdrażanie Liquid Glass z iOS 26.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.