Agent skill

Swiftui Patterns

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

MITAuto-check passedMobile

Install Swiftui Patterns

skills CLI

$ npx skills add affaan-m/ECC --skill swiftui-patterns -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install affaan-m/ECC swiftui-patterns --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/swiftui-patterns .claude/skills/swiftui-patterns && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "swiftui-patterns" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/swiftui-patterns into .claude/skills/swiftui-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "swiftui-patterns", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/affaan-m/ECC/tree/main/skills/swiftui-patterns

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add affaan-m/ECC --skill swiftui-patterns -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install affaan-m/ECC swiftui-patterns --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/swiftui-patterns .agents/skills/swiftui-patterns && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "swiftui-patterns" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/swiftui-patterns into .agents/skills/swiftui-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "swiftui-patterns", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add affaan-m/ECC --skill swiftui-patterns -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install affaan-m/ECC swiftui-patterns --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/swiftui-patterns .cursor/skills/swiftui-patterns && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "swiftui-patterns" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/swiftui-patterns into .cursor/skills/swiftui-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "swiftui-patterns", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/affaan-m/ECC.git --path skills/swiftui-patterns

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add affaan-m/ECC --skill swiftui-patterns -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install affaan-m/ECC swiftui-patterns --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/swiftui-patterns .gemini/skills/swiftui-patterns && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "swiftui-patterns" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/swiftui-patterns into .gemini/skills/swiftui-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "swiftui-patterns", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install affaan-m/ECC swiftui-patterns

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add affaan-m/ECC --skill swiftui-patterns -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/swiftui-patterns .github/skills/swiftui-patterns && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "swiftui-patterns" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/swiftui-patterns into .github/skills/swiftui-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "swiftui-patterns", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add affaan-m/ECC --skill swiftui-patterns -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install affaan-m/ECC swiftui-patterns --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/swiftui-patterns .opencode/skills/swiftui-patterns && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "swiftui-patterns" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/swiftui-patterns into .opencode/skills/swiftui-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "swiftui-patterns", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: swiftui-patterns
GitHub stars: 276k
Used in: 4 other repos
Token cost: ~1.8k tokens
SKILL.md length: 374 words
Files: 1
Skills in repo: 683
Repo updated: Oct 10, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

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

Reviewing SwiftUI views
SKILL.md covers When to Activate, State Management, View Composition and Navigation, plus 4 more sections
Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
@Observable state

What it does

Swiftui Patterns is an agent skill from affaan-m/ECC. SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices. Use when building or reviewing SwiftUI views, @Observable state, navigation, or render performance.

Its SKILL.md is about 1.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Mobile, covering iOS development and State management. It works with SwiftUI, iOS and macOS. The repository describes itself as: The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond. The licence is MIT.

When your agent uses it

Reviewing SwiftUI views
@Observable state
Render performance

Example prompts

“/swiftui-patterns”

What it can do on your machine

Read from SKILL.md and the folder at commit 4eb71d9. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md (its code samples are swift).
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Swiftui Patterns loads about 1.8k tokens when it runs. Until then it costs about 70 tokens; SKILL.md has 374 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~70
When it runs · the whole SKILL.md, loaded when a task matches: ~1.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from affaan-m/ECC at commit 4eb71d9, republished under its MIT licence (© affaan-m). 374 words, ~1,756 tokens.

Download SKILL.mdSave it as .claude/skills/swiftui-patterns/SKILL.md (or your agent's skills folder).

name: swiftui-patterns
description: SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices. Use when building or reviewing SwiftUI views, @Observable state, navigation, or render performance.

SwiftUI Patterns

Modern SwiftUI patterns for building declarative, performant user interfaces on Apple platforms. Covers the Observation framework, view composition, type-safe navigation, and performance optimization.

When to Activate

Building SwiftUI views and managing state (@State, @Observable, @Binding)
Designing navigation flows with NavigationStack
Structuring view models and data flow
Optimizing rendering performance for lists and complex layouts
Working with environment values and dependency injection in SwiftUI

State Management

Property Wrapper Selection

Choose the simplest wrapper that fits:

Wrapper	Use Case
`@State`	View-local value types (toggles, form fields, sheet presentation)
`@Binding`	Two-way reference to parent's `@State`
`@Observable` class + `@State`	Owned model with multiple properties
`@Observable` class (no wrapper)	Read-only reference passed from parent
`@Bindable`	Two-way binding to an `@Observable` property
`@Environment`	Shared dependencies injected via `.environment()`

@Observable ViewModel

Use @Observable (not ObservableObject) — it tracks property-level changes so SwiftUI only re-renders views that read the changed property:

swift

@Observable
final class ItemListViewModel {
    private(set) var items: [Item] = []
    private(set) var isLoading = false
    var searchText = ""

    private let repository: any ItemRepository

    init(repository: any ItemRepository = DefaultItemRepository()) {
        self.repository = repository
    }

    func load() async {
        isLoading = true
        defer { isLoading = false }
        items = (try? await repository.fetchAll()) ?? []
    }
}

View Consuming the ViewModel

swift

struct ItemListView: View {
    @State private var viewModel: ItemListViewModel

    init(viewModel: ItemListViewModel = ItemListViewModel()) {
        _viewModel = State(initialValue: viewModel)
    }

    var body: some View {
        List(viewModel.items) { item in
            ItemRow(item: item)
        }
        .searchable(text: $viewModel.searchText)
        .overlay { if viewModel.isLoading { ProgressView() } }
        .task { await viewModel.load() }
    }
}

Environment Injection

Replace @EnvironmentObject with @Environment:

swift

// Inject
ContentView()
    .environment(authManager)

// Consume
struct ProfileView: View {
    @Environment(AuthManager.self) private var auth

    var body: some View {
        Text(auth.currentUser?.name ?? "Guest")
    }
}

View Composition

Extract Subviews to Limit Invalidation

Break views into small, focused structs. When state changes, only the subview reading that state re-renders:

swift

struct OrderView: View {
    @State private var viewModel = OrderViewModel()

    var body: some View {
        VStack {
            OrderHeader(title: viewModel.title)
            OrderItemList(items: viewModel.items)
            OrderTotal(total: viewModel.total)
        }
    }
}

ViewModifier for Reusable Styling

swift

struct CardModifier: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding()
            .background(.regularMaterial)
            .clipShape(RoundedRectangle(cornerRadius: 12))
    }
}

extension View {
    func cardStyle() -> some View {
        modifier(CardModifier())
    }
}

Type-Safe NavigationStack

Use NavigationStack with NavigationPath for programmatic, type-safe routing:

swift

@Observable
final class Router {
    var path = NavigationPath()

    func navigate(to destination: Destination) {
        path.append(destination)
    }

    func popToRoot() {
        path = NavigationPath()
    }
}

enum Destination: Hashable {
    case detail(Item.ID)
    case settings
    case profile(User.ID)
}

struct RootView: View {
    @State private var router = Router()

    var body: some View {
        NavigationStack(path: $router.path) {
            HomeView()
                .navigationDestination(for: Destination.self) { dest in
                    switch dest {
                    case .detail(let id): ItemDetailView(itemID: id)
                    case .settings: SettingsView()
                    case .profile(let id): ProfileView(userID: id)
                    }
                }
        }
        .environment(router)
    }
}

Performance

Use Lazy Containers for Large Collections

LazyVStack and LazyHStack create views only when visible:

swift

ScrollView {
    LazyVStack(spacing: 8) {
        ForEach(items) { item in
            ItemRow(item: item)
        }
    }
}

Stable Identifiers

Always use stable, unique IDs in ForEach — avoid using array indices:

swift

// Use Identifiable conformance or explicit id
ForEach(items, id: \.stableID) { item in
    ItemRow(item: item)
}

Show full SKILL.md (154 more words)Show less

Avoid Expensive Work in body

Never perform I/O, network calls, or heavy computation inside body
Use .task {} for async work — it cancels automatically when the view disappears
Use .sensoryFeedback() and .geometryGroup() sparingly in scroll views
Minimize .shadow(), .blur(), and .mask() in lists — they trigger offscreen rendering

Equatable Conformance

For views with expensive bodies, conform to Equatable to skip unnecessary re-renders:

swift

struct ExpensiveChartView: View, Equatable {
    let dataPoints: [DataPoint] // DataPoint must conform to Equatable

    static func == (lhs: Self, rhs: Self) -> Bool {
        lhs.dataPoints == rhs.dataPoints
    }

    var body: some View {
        // Complex chart rendering
    }
}

Previews

Use #Preview macro with inline mock data for fast iteration:

swift

#Preview("Empty state") {
    ItemListView(viewModel: ItemListViewModel(repository: EmptyMockRepository()))
}

#Preview("Loaded") {
    ItemListView(viewModel: ItemListViewModel(repository: PopulatedMockRepository()))
}

Anti-Patterns to Avoid

Using ObservableObject / @Published / @StateObject / @EnvironmentObject in new code — migrate to @Observable
Putting async work directly in body or init — use .task {} or explicit load methods
Creating view models as @State inside child views that don't own the data — pass from parent instead
Using AnyView type erasure — prefer @ViewBuilder or Group for conditional views
Ignoring Sendable requirements when passing data to/from actors

References

See skill: swift-actor-persistence for actor-based persistence patterns. See skill: swift-protocol-di-testing for protocol-based DI and testing with Swift Testing.

Files

Just SKILL.md in skills/swiftui-patterns of affaan-m/ECC.

Open the folder on GitHubat commit 4eb71d9

Used in 4 other repositories

We found 10 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 4 other GitHub owners. This page covers the copy in affaan-m/ECC, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Swiftui Patterns next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Swiftui Patterns compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Swiftui Patterns this skillaffaan-m/ECC	276k	4 repos	~1.8k	Automated safety check: Pass	MIT	today
Swiftui Expert Skillsupabitapp/supaterm	172	—	~1.5k	Automated safety check: Pass	Custom licence	16 days ago
iOS Patternshanamizuki/solopreneur	152	—	~2.3k	Automated safety check: Notes	MIT	13 days ago
Swiftui Expert Skillomarshahine/HomeClaw	175	4 repos	~2.8k	Automated safety check: Pass	MIT	2 days ago
Appkit Swiftui BridgeKartikLabhshetwar/better-shot	2.4k	2 repos	~1.1k	Automated safety check: Pass	Custom licence	yesterday
Hig Project Contextraintree-technology/hig-doctor	143	5 repos	~1.2k	Automated safety check: Pass	MIT	29 days ago

Similar skills

Swiftui Expert Skill
supabitapp/supaterm
Write, review, or improve SwiftUI code following best practices for state management, view composition, performance, macOS-specific APIs, and iOS 26+ Liquid Glass adoption.
172 GitHub stars~1.5k tokensUpdated 16 days ago
MobileAuto-check passed
iOS Patterns
hanamizuki/solopreneur
A skill your agent uses when building iOS/macOS apps with SwiftUI — covers localization (String Catalogs), date/time formatting, JSON date decoding, Previews, state management, sheet/navigation…
152 GitHub stars~2.3k tokensUpdated 13 days ago
Frontend & DesignAuto-check: notes
Swiftui Expert Skill
omarshahine/HomeClaw
A skill your agent uses when writing, reviewing, or refactoring SwiftUI code for iOS or macOS, including state management, view composition, performance, Liquid Glass adoption, or Instruments .trace…
175 GitHub starsUsed in 4 repos~2.8k tokens
MobileAuto-check passed
Appkit Swiftui Bridge
KartikLabhshetwar/better-shot
Expert guidance for hybrid AppKit-SwiftUI development. An agent skill from KartikLabhshetwar/better-shot.
2.4k GitHub starsUsed in 2 repos~1.1k tokens
MobileAuto-check passed
Hig Project Context
raintree-technology/hig-doctor
Create or update a shared Apple design context document that other HIG skills use to tailor guidance.
143 GitHub starsUsed in 5 repos~1.2k tokens
MobileAuto-check passed
Swiftui Expert Skill
ilyas-hallak/romm-ios-app
Write, review, or improve SwiftUI code following best practices for state management, view composition, performance, and iOS 26+ Liquid Glass adoption.
169 GitHub starsUsed in 1 repo~2.9k tokens
MobileAuto-check passed

Questions about Swiftui Patterns

What does Swiftui Patterns do?

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices. Swiftui Patterns is an agent skill from affaan-m/ECC. SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

When should I use Swiftui Patterns?

Swiftui Patterns fits situations like: reviewing SwiftUI views; @Observable state; render performance.

How do I install Swiftui Patterns in Claude Code?

Run `npx skills add affaan-m/ECC --skill swiftui-patterns -a claude-code`. Or copy the skill folder (skills/swiftui-patterns in affaan-m/ECC) into .claude/skills/swiftui-patterns in your project. Claude Code loads it when a task matches its description.

How do I install Swiftui Patterns in Codex?

Run `npx skills add affaan-m/ECC --skill swiftui-patterns -a codex`. Or copy the skill folder (skills/swiftui-patterns in affaan-m/ECC) into .agents/skills/swiftui-patterns in your project. Codex loads it when a task matches its description.

Can I use Swiftui Patterns in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add affaan-m/ECC --skill swiftui-patterns -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/swiftui-patterns, .gemini/skills/swiftui-patterns, .github/skills/swiftui-patterns and .opencode/skills/swiftui-patterns in your project.

What does Swiftui Patterns need to run?

SKILL.md names no scripts, command-line tools or credentials: Swiftui Patterns is instructions for the agent only.

Does Swiftui Patterns access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Swiftui Patterns safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Swiftui Patterns use?

Swiftui Patterns is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Swiftui Patterns use?

About 1.8k tokens (SKILL.md is roughly 7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Swiftui Patterns?

Skills that share tags, products or a category with Swiftui Patterns: Swiftui Expert Skill (supabitapp/supaterm, 172 stars), iOS Patterns (hanamizuki/solopreneur, 152 stars), Swiftui Expert Skill (omarshahine/HomeClaw, 175 stars) and Appkit Swiftui Bridge (KartikLabhshetwar/better-shot, 2.4k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Swiftui Patterns?

affaan-m (a GitHub user) maintains it in affaan-m/ECC, which has 276,111 GitHub stars. The repository holds 683 skills in this directory. The repository was last updated on October 10, 2026.

Source: affaan-m/ECC on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Swiftui Patterns

Facts

At a glance

What it does

When your agent uses it

Example prompts

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

SwiftUI Patterns

When to Activate

State Management

Property Wrapper Selection

@Observable ViewModel

View Consuming the ViewModel

Environment Injection

View Composition

Extract Subviews to Limit Invalidation

ViewModifier for Reusable Styling

Navigation

Type-Safe NavigationStack

Performance

Use Lazy Containers for Large Collections

Stable Identifiers

Avoid Expensive Work in body

Equatable Conformance

Previews

Anti-Patterns to Avoid

References

Files

Used in 4 other repositories

Compare with similar skills

Similar skills

More from affaan-m/ECC

Related

Questions about Swiftui Patterns