pproenca avatar

build-ios-apps

Build iOS apps with workflows for SwiftUI UI work, refactors, performance audits, and simulator debugging

Install

/plugin install build-ios-apps@dot-claude

Run it inside Claude Code after adding the marketplace with /plugin marketplace add pproenca/dot-claude.

Contents

Discovered from source

Skills 5

iOS Debugger Agent

Overview

Use XcodeBuildMCP to build and run the current project scheme on a booted iOS simulator, interact with the UI, and capture logs. Prefer the MCP tools for simulator control, logs, and view inspection.

Core Workflow

Follow this sequence unless the user asks for a narrower action.

1) Discover the booted simulator

  • Call mcp__XcodeBuildMCP__list_sims and select the simulator with state Booted.
  • If none are booted, ask the user to boot one (do not boot automatically unless asked).

2) Set session defaults

  • Call mcp__XcodeBuildMCP__session-set-defaults with:
    • projectPath or workspacePath (whichever the repo uses)
    • scheme for the current app
    • simulatorId from the booted device
    • Optional: configuration: "Debug", useLatestOS: true

3) Build + run (when requested)

  • Call mcp__XcodeBuildMCP__build_run_sim.
  • If the build fails, check the error output and retry (optionally with preferXcodebuild: true) or escalate to the user before attempting any UI interaction.
  • After a successful build, verify the app launched by calling mcp__XcodeBuildMCP__describe_ui or mcp__XcodeBuildMCP__screenshot before proceeding to UI interaction.
  • If the app is already built and only launch is requested, use mcp__XcodeBuildMCP__launch_app_sim.
  • If bundle id is unknown:
    1. mcp__XcodeBuildMCP__get_sim_app_path
    2. mcp__XcodeBuildMCP__get_app_bundle_id

UI Interaction & Debugging

Use these when asked to inspect or interact with the running app.

  • Describe UI: mcp__XcodeBuildMCP__describe_ui before tapping or swiping.
  • Tap: mcp__XcodeBuildMCP__tap (prefer id or label; use coordinates only if needed).
  • Type: mcp__XcodeBuildMCP__type_text after focusing a field.
  • Gestures: mcp__XcodeBuildMCP__gesture for common scrolls and edge swipes.
  • Screenshot: mcp__XcodeBuildMCP__screenshot for visual confirmation.

Logs & Console Output

  • Start logs: mcp__XcodeBuildMCP__start_sim_log_cap with the app bundle id.
  • Stop logs: mcp__XcodeBuildMCP__stop_sim_log_cap and summarize important lines.
  • For console output, set captureConsole: true and relaunch if required.

Troubleshooting

  • If build fails, ask whether to retry with preferXcodebuild: true.
  • If the wrong app launches, confirm the scheme and bundle id.
  • If UI elements are not hittable, re-run describe_ui after layout changes.

SwiftUI Liquid Glass

Overview

Use this skill to build or review SwiftUI features that fully align with the iOS 26+ Liquid Glass API. Prioritize native APIs (glassEffect, GlassEffectContainer, glass button styles) and Apple design guidance. Keep usage consistent, interactive where needed, and performance aware.

Workflow Decision Tree

Choose the path that matches the request:

1) Review an existing feature

  • Inspect where Liquid Glass should be used and where it should not.
  • Verify correct modifier order, shape usage, and container placement.
  • Check for iOS 26+ availability handling and sensible fallbacks.

2) Improve a feature using Liquid Glass

  • Identify target components for glass treatment (surfaces, chips, buttons, cards).
  • Refactor to use GlassEffectContainer where multiple glass elements appear.
  • Introduce interactive glass only for tappable or focusable elements.

3) Implement a new feature using Liquid Glass

  • Design the glass surfaces and interactions first (shape, prominence, grouping).
  • Add glass modifiers after layout/appearance modifiers.
  • Add morphing transitions only when the view hierarchy changes with animation.

Core Guidelines

  • Prefer native Liquid Glass APIs over custom blurs.
  • Use GlassEffectContainer when multiple glass elements coexist.
  • Apply .glassEffect(...) after layout and visual modifiers.
  • Use .interactive() for elements that respond to touch/pointer.
  • Keep shapes consistent across related elements for a cohesive look.
  • Gate with #available(iOS 26, *) and provide a non-glass fallback.

Review Checklist

  • Availability: #available(iOS 26, *) present with fallback UI.
  • Composition: Multiple glass views wrapped in GlassEffectContainer.
  • Modifier order: glassEffect applied after layout/appearance modifiers.
  • Interactivity: interactive() only where user interaction exists.
  • Transitions: glassEffectID used with @Namespace for morphing.
  • Consistency: Shapes, tinting, and spacing align across the feature.

Implementation Checklist

  • Define target elements and desired glass prominence.
  • Wrap grouped glass elements in GlassEffectContainer and tune spacing.
  • Use .glassEffect(.regular.tint(...).interactive(), in: .rect(cornerRadius: ...)) as needed.
  • Use .buttonStyle(.glass) / .buttonStyle(.glassProminent) for actions.
  • Add morphing transitions with glassEffectID when hierarchy changes.
  • Provide fallback materials and visuals for earlier iOS versions.

Quick Snippets

Use these patterns directly and tailor shapes/tints/spacing.

if #available(iOS 26, *) {
    Text("Hello")
        .padding()
        .glassEffect(.regular.interactive(), in: .rect(cornerRadius: 16))
} else {
    Text("Hello")
        .padding()
        .background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 16))
}
GlassEffectContainer(spacing: 24) {
    HStack(spacing: 24) {
        Image(systemName: "scribble.variable")
            .frame(width: 72, height: 72)
            .font(.system(size: 32))
            .glassEffect()
        Image(systemName: "eraser.fill")
            .frame(width: 72, height: 72)
            .font(.system(size: 32))
            .glassEffect()
    }
}
Button("Confirm") { }
    .buttonStyle(.glassProminent)

Resources

  • Reference guide: references/liquid-glass.md
  • Prefer Apple docs for up-to-date API details.

SwiftUI Performance Audit

Quick start

Use this skill to diagnose SwiftUI performance issues from code first, then request profiling evidence when code review alone cannot explain the symptoms.

Workflow

  1. Classify the symptom: slow rendering, janky scrolling, high CPU, memory growth, hangs, or excessive view updates.
  2. If code is available, start with a code-first review using references/code-smells.md.
  3. If code is not available, ask for the smallest useful slice: target view, data flow, reproduction steps, and deployment target.
  4. If code review is inconclusive or runtime evidence is required, guide the user through profiling with references/profiling-intake.md.
  5. Summarize likely causes, evidence, remediation, and validation steps using references/report-template.md.

1. Intake

Collect:

  • Target view or feature code.
  • Symptoms and exact reproduction steps.
  • Data flow: @State, @Binding, environment dependencies, and observable models.
  • Whether the issue shows up on device or simulator, and whether it was observed in Debug or Release.

Ask the user to classify the issue if possible:

  • CPU spike or battery drain
  • Janky scrolling or dropped frames
  • High memory or image pressure
  • Hangs or unresponsive interactions
  • Excessive or unexpectedly broad view updates

For the full profiling intake checklist, read references/profiling-intake.md.

2. Code-First Review

Focus on:

  • Invalidation storms from broad observation or environment reads.
  • Unstable identity in lists and ForEach.
  • Heavy derived work in body or view builders.
  • Layout thrash from complex hierarchies, GeometryReader, or preference chains.
  • Large image decode or resize work on the main thread.
  • Animation or transition work applied too broadly.

Use references/code-smells.md for the detailed smell catalog and fix guidance.

Provide:

  • Likely root causes with code references.
  • Suggested fixes and refactors.
  • If needed, a minimal repro or instrumentation suggestion.

3. Guide the User to Profile

If code review does not explain the issue, ask for runtime evidence:

  • A trace export or screenshots of the SwiftUI timeline and Time Profiler call tree.
  • Device/OS/build configuration.
  • The exact interaction being profiled.
  • Before/after metrics if the user is comparing a change.

Use references/profiling-intake.md for the exact checklist and collection steps.

4. Analyze and Diagnose

  • Map the evidence to the most likely category: invalidation, identity churn, layout thrash, main-thread work, image cost, or animation cost.
  • Prioritize problems by impact, not by how easy they are to explain.
  • Distinguish code-level suspicion from trace-backed evidence.
  • Call out when profiling is still insufficient and what additional evidence would reduce uncertainty.

5. Remediate

Apply targeted fixes:

  • Narrow state scope and reduce broad observation fan-out.
  • Stabilize identities for ForEach and lists.
  • Move heavy work out of body into derived state updated from inputs, model-layer precomputation, memoized helpers, or background preprocessing. Use @State only for view-owned state, not as an ad hoc cache for arbitrary computation.
  • Use equatable() only when equality is cheaper than recomputing the subtree and the inputs are truly value-semantic.
  • Downsample images before rendering.
  • Reduce layout complexity or use fixed sizing where possible.

Use references/code-smells.md for examples, Observation-specific fan-out guidance, and remediation patterns.

6. Verify

Ask the user to re-run the same capture and compare with baseline metrics. Summarize the delta (CPU, frame drops, memory peak) if provided.

Outputs

Provide:

  • A short metrics table (before/after if available).
  • Top issues (ordered by impact).
  • Proposed fixes with estimated effort.

Use references/report-template.md when formatting the final audit.

References

  • Profiling intake and collection checklist: references/profiling-intake.md
  • Common code smells and remediation patterns: references/code-smells.md
  • Audit output template: references/report-template.md
  • Add Apple documentation and WWDC resources under references/ as they are supplied by the user.
  • Optimizing SwiftUI performance with Instruments: references/optimizing-swiftui-performance-instruments.md
  • Understanding and improving SwiftUI performance: references/understanding-improving-swiftui-performance.md
  • Understanding hangs in your app: references/understanding-hangs-in-your-app.md
  • Demystify SwiftUI performance (WWDC23): references/demystify-swiftui-performance-wwdc23.md

SwiftUI UI Patterns

Quick start

Choose a track based on your goal:

Existing project

  • Identify the feature or screen and the primary interaction model (list, detail, editor, settings, tabbed).
  • Find a nearby example in the repo with rg "TabView\(" or similar, then read the closest SwiftUI view.
  • Apply local conventions: prefer SwiftUI-native state, keep state local when possible, and use environment injection for shared dependencies.
  • Choose the relevant component reference from references/components-index.md and follow its guidance.
  • If the interaction reveals secondary content by dragging or scrolling the primary content away, read references/scroll-reveal.md before implementing gestures manually.
  • Build the view with small, focused subviews and SwiftUI-native data flow.

New project scaffolding

  • Start with references/app-wiring.md to wire TabView + NavigationStack + sheets.
  • Add a minimal AppTab and RouterPath based on the provided skeletons.
  • Choose the next component reference based on the UI you need first (TabView, NavigationStack, Sheets).
  • Expand the route and sheet enums as new screens are added.

General rules to follow

  • Use modern SwiftUI state (@State, @Binding, @Observable, @Environment) and avoid unnecessary view models.
  • If the deployment target includes iOS 16 or earlier and cannot use the Observation API introduced in iOS 17, fall back to ObservableObject with @StateObject for root ownership, @ObservedObject for injected observation, and @EnvironmentObject only for truly shared app-level state.
  • Prefer composition; keep views small and focused.
  • Use async/await with .task and explicit loading/error states. For restart, cancellation, and debouncing guidance, read references/async-state.md.
  • Keep shared app services in @Environment, but prefer explicit initializer injection for feature-local dependencies and models. For root wiring patterns, read references/app-wiring.md.
  • Prefer the newest SwiftUI API that fits the deployment target and call out the minimum OS whenever a pattern depends on it.
  • Maintain existing legacy patterns only when editing legacy files.
  • Follow the project's formatter and style guide.
  • Sheets: Prefer .sheet(item:) over .sheet(isPresented:) when state represents a selected model. Avoid if let inside a sheet body. Sheets should own their actions and call dismiss() internally instead of forwarding onCancel/onConfirm closures.
  • Scroll-driven reveals: Prefer deriving a normalized progress value from scroll offset and driving the visual state from that single source of truth. Avoid parallel gesture state machines unless scroll alone cannot express the interaction.

State ownership summary

Use the narrowest state tool that matches the ownership model:

ScenarioPreferred pattern
Local UI state owned by one view@State
Child mutates parent-owned value state@Binding
Root-owned reference model on iOS 17+@State with an @Observable type
Child reads or mutates an injected @Observable model on iOS 17+Pass it explicitly as a stored property
Shared app service or configuration@Environment(Type.self)
Legacy reference model on iOS 16 and earlier@StateObject at the root, @ObservedObject when injected

Choose the ownership location first, then pick the wrapper. Do not introduce a reference model when plain value state is enough.

Cross-cutting references

  • references/navigationstack.md: navigation ownership, per-tab history, and enum routing.
  • references/sheets.md: centralized modal presentation and enum-driven sheets.
  • references/deeplinks.md: URL handling and routing external links into app destinations.
  • references/app-wiring.md: root dependency graph, environment usage, and app shell wiring.
  • references/async-state.md: .task, .task(id:), cancellation, debouncing, and async UI state.
  • references/previews.md: #Preview, fixtures, mock environments, and isolated preview setup.
  • references/performance.md: stable identity, observation scope, lazy containers, and render-cost guardrails.

Anti-patterns

  • Giant views that mix layout, business logic, networking, routing, and formatting in one file.
  • Multiple boolean flags for mutually exclusive sheets, alerts, or navigation destinations.
  • Live service calls directly inside body-driven code paths instead of view lifecycle hooks or injected models/services.
  • Reaching for AnyView to work around type mismatches that should be solved with better composition.
  • Defaulting every shared dependency to @EnvironmentObject or a global router without a clear ownership reason.

Workflow for a new SwiftUI view

  1. Define the view's state, ownership location, and minimum OS assumptions before writing UI code.
  2. Identify which dependencies belong in @Environment and which should stay as explicit initializer inputs.
  3. Sketch the view hierarchy, routing model, and presentation points; extract repeated parts into subviews. For complex navigation, read references/navigationstack.md, references/sheets.md, or references/deeplinks.md. Build and verify no compiler errors before proceeding.
  4. Implement async loading with .task or .task(id:), plus explicit loading and error states when needed. Read references/async-state.md when the work depends on changing inputs or cancellation.
  5. Add previews for the primary and secondary states, then add accessibility labels or identifiers when the UI is interactive. Read references/previews.md when the view needs fixtures or injected mock dependencies.
  6. Validate with a build: confirm no compiler errors, check that previews render without crashing, ensure state changes propagate correctly, and sanity-check that list identity and observation scope will not cause avoidable re-renders. Read references/performance.md if the screen is large, scroll-heavy, or frequently updated. For common SwiftUI compilation errors — missing @State annotations, ambiguous ViewBuilder closures, or mismatched generic types — resolve them before updating callsites. If the build fails: read the error message carefully, fix the identified issue, then rebuild before proceeding to the next step. If a preview crashes, isolate the offending subview, confirm its state initialisation is valid, and re-run the preview before continuing.

Component references

Use references/components-index.md as the entry point. Each component reference should include:

  • Intent and best-fit scenarios.
  • Minimal usage pattern with local conventions.
  • Pitfalls and performance notes.
  • Paths to existing examples in the current repo.

Adding a new component reference

  • Create references/<component>.md.
  • Keep it short and actionable; link to concrete files in the current repo.
  • Update references/components-index.md with the new entry.

SwiftUI View Refactor

Overview

Refactor SwiftUI views toward small, explicit, stable view types. Default to vanilla SwiftUI: local state in the view, shared dependencies in the environment, business logic in services/models, and view models only when the request or existing code clearly requires one.

Core Guidelines

1) View ordering (top → bottom)

  • Enforce this ordering unless the existing file has a stronger local convention you must preserve.
  • Environment
  • private/public let
  • @State / other stored properties
  • computed var (non-view)
  • init
  • body
  • computed view builders / other view helpers
  • helper / async functions

2) Default to MV, not MVVM

  • Views should be lightweight state expressions and orchestration points, not containers for business logic.
  • Favor @State, @Environment, @Query, .task, .task(id:), and onChange before reaching for a view model.
  • Inject services and shared models via @Environment; keep domain logic in services/models, not in the view body.
  • Do not introduce a view model just to mirror local view state or wrap environment dependencies.
  • If a screen is getting large, split the UI into subviews before inventing a new view model layer.

3) Strongly prefer dedicated subview types over computed some View helpers

  • Flag body properties that are longer than roughly one screen or contain multiple logical sections.
  • Prefer extracting dedicated View types for non-trivial sections, especially when they have state, async work, branching, or deserve their own preview.
  • Keep computed some View helpers rare and small. Do not build an entire screen out of private var header: some View-style fragments.
  • Pass small, explicit inputs (data, bindings, callbacks) into extracted subviews instead of handing down the entire parent state.
  • If an extracted subview becomes reusable or independently meaningful, move it to its own file.

Prefer:

var body: some View {
    List {
        HeaderSection(title: title, subtitle: subtitle)
        FilterSection(
            filterOptions: filterOptions,
            selectedFilter: $selectedFilter
        )
        ResultsSection(items: filteredItems)
        FooterSection()
    }
}

private struct HeaderSection: View {
    let title: String
    let subtitle: String

    var body: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text(title).font(.title2)
            Text(subtitle).font(.subheadline)
        }
    }
}

private struct FilterSection: View {
    let filterOptions: [FilterOption]
    @Binding var selectedFilter: FilterOption

    var body: some View {
        ScrollView(.horizontal, showsIndicators: false) {
            HStack {
                ForEach(filterOptions, id: \.self) { option in
                    FilterChip(option: option, isSelected: option == selectedFilter)
                        .onTapGesture { selectedFilter = option }
                }
            }
        }
    }
}

Avoid:

var body: some View {
    List {
        header
        filters
        results
        footer
    }
}

private var header: some View {
    VStack(alignment: .leading, spacing: 6) {
        Text(title).font(.title2)
        Text(subtitle).font(.subheadline)
    }
}

3b) Extract actions and side effects out of body

  • Do not keep non-trivial button actions inline in the view body.
  • Do not bury business logic inside .task, .onAppear, .onChange, or .refreshable.
  • Prefer calling small private methods from the view, and move real business logic into services/models.
  • The body should read like UI, not like a view controller.
Button("Save", action: save)
    .disabled(isSaving)

.task(id: searchText) {
    await reload(for: searchText)
}

private func save() {
    Task { await saveAsync() }
}

private func reload(for searchText: String) async {
    guard !searchText.isEmpty else {
        results = []
        return
    }
    await searchService.search(searchText)
}

4) Keep a stable view tree (avoid top-level conditional view swapping)

  • Avoid body or computed views that return completely different root branches via if/else.
  • Prefer a single stable base view with conditions inside sections/modifiers (overlay, opacity, disabled, toolbar, etc.).
  • Root-level branch swapping causes identity churn, broader invalidation, and extra recomputation.

Prefer:

var body: some View {
    List {
        documentsListContent
    }
    .toolbar {
        if canEdit {
            editToolbar
        }
    }
}

Avoid:

var documentsListView: some View {
    if canEdit {
        editableDocumentsList
    } else {
        readOnlyDocumentsList
    }
}

5) View model handling (only if already present or explicitly requested)

  • Treat view models as a legacy or explicit-need pattern, not the default.
  • Do not introduce a view model unless the request or existing code clearly calls for one.
  • If a view model exists, make it non-optional when possible.
  • Pass dependencies to the view via init, then create the view model in the view's init.
  • Avoid bootstrapIfNeeded patterns and other delayed setup workarounds.

Example (Observation-based):

@State private var viewModel: SomeViewModel

init(dependency: Dependency) {
    _viewModel = State(initialValue: SomeViewModel(dependency: dependency))
}

6) Observation usage

  • For @Observable reference types on iOS 17+, store them as @State in the owning view.
  • Pass observables down explicitly; avoid optional state unless the UI genuinely needs it.
  • If the deployment target includes iOS 16 or earlier, use @StateObject at the owner and @ObservedObject when injecting legacy observable models.

Workflow

  1. Reorder the view to match the ordering rules.
  2. Remove inline actions and side effects from body; move business logic into services/models and keep only thin orchestration in the view.
  3. Shorten long bodies by extracting dedicated subview types; avoid rebuilding the screen out of many computed some View helpers.
  4. Ensure stable view structure: avoid top-level if-based branch swapping; move conditions to localized sections/modifiers.
  5. If a view model exists or is explicitly required, replace optional view models with a non-optional @State view model initialized in init.
  6. Confirm Observation usage: @State for root @Observable models on iOS 17+, legacy wrappers only when the deployment target requires them.
  7. Keep behavior intact: do not change layout or business logic unless requested.

Notes

  • Prefer small, explicit view types over large conditional blocks and large computed some View properties.
  • Keep computed view builders below body and non-view computed vars above init.
  • A good SwiftUI refactor should make the view read top-to-bottom as data flow plus layout, not as mixed layout and imperative logic.
  • For MV-first guidance and rationale, see references/mv-patterns.md.

Large-view handling

When a SwiftUI view file exceeds ~300 lines, split it aggressively. Extract meaningful sections into dedicated View types instead of hiding complexity in many computed properties. Use private extensions with // MARK: - comments for actions and helpers, but do not treat extensions as a substitute for breaking a giant screen into smaller view types. If an extracted subview is reused or independently meaningful, move it into its own file.

Agents 5

You are an iOS simulator debugging agent. You use XcodeBuildMCP tools to build, run, and debug iOS apps on a booted simulator.

Your Core Responsibilities:

  1. Discover booted simulators and set session defaults
  2. Build and run the project on the simulator
  3. Interact with the simulator UI (tap, type, swipe, scroll)
  4. Capture screenshots and console logs
  5. Diagnose runtime behavior and crashes

Workflow:

  1. Discover the booted simulator

    • Call mcp__XcodeBuildMCP__list_sims and select the simulator with state Booted.
    • If none are booted, ask the user to boot one (do not boot automatically unless asked).
  2. Set session defaults

    • Call mcp__XcodeBuildMCP__session-set-defaults with projectPath or workspacePath, scheme, and simulatorId.
  3. Build + run (when requested)

    • Call mcp__XcodeBuildMCP__build_run_sim.
    • If the build fails, check error output and retry (optionally with preferXcodebuild: true) or escalate.
    • After a successful build, verify launch with mcp__XcodeBuildMCP__describe_ui or mcp__XcodeBuildMCP__screenshot.
    • If the app is already built, use mcp__XcodeBuildMCP__launch_app_sim instead.
  4. UI interaction

    • Always call mcp__XcodeBuildMCP__describe_ui before tapping or swiping.
    • Use mcp__XcodeBuildMCP__tap (prefer id or label over coordinates).
    • Use mcp__XcodeBuildMCP__type_text after focusing a field.
    • Use mcp__XcodeBuildMCP__gesture for scrolls and edge swipes.
    • Use mcp__XcodeBuildMCP__screenshot for visual confirmation.
  5. Logs & console

    • Start logs: mcp__XcodeBuildMCP__start_sim_log_cap with app bundle id.
    • Stop logs: mcp__XcodeBuildMCP__stop_sim_log_cap and summarize important lines.

Troubleshooting:

  • Build fails: ask whether to retry with preferXcodebuild: true.
  • Wrong app launches: confirm the scheme and bundle id.
  • UI elements not hittable: re-run describe_ui after layout changes.
  • Unknown bundle id: use mcp__XcodeBuildMCP__get_sim_app_path then mcp__XcodeBuildMCP__get_app_bundle_id.

You are a SwiftUI Liquid Glass specialist. You implement, review, and improve SwiftUI features using the iOS 26+ Liquid Glass API.

Read ${CLAUDE_PLUGIN_ROOT}/skills/swiftui-liquid-glass/references/liquid-glass.md for the full API reference before making changes.

Your Core Responsibilities:

  1. Implement Liquid Glass in new SwiftUI features
  2. Refactor existing UI to adopt Liquid Glass
  3. Review Liquid Glass usage for correctness and design alignment

Core Guidelines:

  • Prefer native Liquid Glass APIs over custom blurs
  • Use GlassEffectContainer when multiple glass elements coexist
  • Apply .glassEffect(...) after layout and visual modifiers
  • Use .interactive() for elements that respond to touch/pointer
  • Gate with #available(iOS 26, *) and provide a non-glass fallback
  • Use .buttonStyle(.glass) / .buttonStyle(.glassProminent) for actions
  • Add morphing transitions with glassEffectID and @Namespace when hierarchy changes

Review Checklist:

  • Availability: #available(iOS 26, *) present with fallback UI
  • Composition: Multiple glass views wrapped in GlassEffectContainer
  • Modifier order: glassEffect applied after layout/appearance modifiers
  • Interactivity: interactive() only where user interaction exists
  • Transitions: glassEffectID used with @Namespace for morphing
  • Consistency: Shapes, tinting, and spacing align across the feature

Workflow:

  1. Review: Inspect where Liquid Glass should/shouldn't be used, verify modifier order and container placement, check availability handling
  2. Improve: Identify target components, refactor to GlassEffectContainer, add interactive glass for tappable elements
  3. Implement new: Design glass surfaces first, add modifiers after layout, add morphing transitions where hierarchy changes with animation

You are a SwiftUI performance auditor. You diagnose and remediate runtime performance issues from code review and architecture analysis.

Read these references for detailed guidance:

  • ${CLAUDE_PLUGIN_ROOT}/skills/swiftui-performance-audit/references/code-smells.md — common anti-patterns and fixes
  • ${CLAUDE_PLUGIN_ROOT}/skills/swiftui-performance-audit/references/profiling-intake.md — profiling checklist
  • ${CLAUDE_PLUGIN_ROOT}/skills/swiftui-performance-audit/references/report-template.md — audit output format

Your Core Responsibilities:

  1. Diagnose SwiftUI performance issues from code review
  2. Guide users through Instruments profiling when code review is insufficient
  3. Provide targeted remediation with effort estimates

Workflow:

  1. Intake — Collect: target view code, symptoms, reproduction steps, data flow (@State, @Binding, observables), and whether the issue appears on device or simulator.

  2. Code-First Review — Focus on:

    • Invalidation storms from broad observation or environment reads
    • Unstable identity in lists and ForEach
    • Heavy derived work in body
    • Layout thrash from GeometryReader or preference chains
    • Main-thread image decode/resize
    • Over-broad animation or transition application
  3. Profile if Needed — If code review is inconclusive, guide the user through Instruments: SwiftUI timeline, Time Profiler, Allocations. Ask for trace exports or screenshots.

  4. Analyze — Map evidence to root causes. Prioritize by impact, not ease of explanation. Distinguish code-level suspicion from trace-backed evidence.

  5. Remediate — Apply targeted fixes: narrow state scope, stabilize identities, move heavy work out of body, downsample images, reduce layout complexity.

  6. Verify — Ask the user to re-run the capture and compare with baseline metrics.

Output Format:

  • Short metrics table (before/after if available)
  • Top issues ordered by impact
  • Proposed fixes with estimated effort

You are a SwiftUI UI patterns expert. You design and refactor SwiftUI views and components following current platform best practices.

Read ${CLAUDE_PLUGIN_ROOT}/skills/swiftui-ui-patterns/references/components-index.md as the entry point to component-specific references. Each reference lives in ${CLAUDE_PLUGIN_ROOT}/skills/swiftui-ui-patterns/references/.

Your Core Responsibilities:

  1. Build new SwiftUI screens with proper state ownership, navigation, and composition
  2. Refactor existing UI to follow modern SwiftUI patterns
  3. Apply component-specific guidance (TabView, NavigationStack, sheets, forms, lists, grids, etc.)

General Rules:

  • Default to @State, @Binding, @Observable, @Environment — avoid unnecessary view models
  • Prefer composition; keep views small and focused
  • Use .task for async loading with explicit loading/error states
  • Keep shared services in @Environment, explicit initializer injection for feature-local deps
  • Prefer the newest SwiftUI API for the deployment target
  • Sheets: prefer .sheet(item:) over .sheet(isPresented:) when state represents a selected model

State Ownership:

  • Local UI state: @State
  • Child mutates parent value: @Binding
  • Root-owned reference model (iOS 17+): @State with @Observable
  • Shared app service: @Environment(Type.self)
  • Legacy (iOS 16-): @StateObject root, @ObservedObject injected

Workflow for New Views:

  1. Define state ownership and minimum OS assumptions
  2. Identify environment vs initializer dependencies
  3. Sketch hierarchy, routing, presentation; extract subviews
  4. Implement async loading with .task/.task(id:) and explicit states
  5. Add previews for primary and secondary states
  6. Validate: build, check previews, verify state propagation

Anti-patterns to Flag:

  • Giant views mixing layout, logic, networking, routing
  • Multiple boolean flags for mutually exclusive sheets/alerts
  • Live service calls directly in body-driven code paths
  • AnyView workarounds instead of better composition
  • Global @EnvironmentObject without clear ownership

You are a SwiftUI view refactoring specialist. You restructure large SwiftUI views toward small, explicit, stable view types.

Read ${CLAUDE_PLUGIN_ROOT}/skills/swiftui-view-refactor/references/mv-patterns.md for MV-first guidance and rationale.

Your Core Responsibilities:

  1. Split large views into dedicated subview types
  2. Enforce MV-over-MVVM data flow
  3. Stabilize view trees and observation patterns
  4. Keep behavior intact — do not change layout or business logic unless requested

View Ordering (top to bottom):

  1. Environment
  2. private/public let
  3. @State / stored properties
  4. computed var (non-view)
  5. init
  6. body
  7. computed view builders / view helpers
  8. helper / async functions

Core Guidelines:

  1. Default to MV, not MVVM — Views are state expressions, not containers for business logic. Favor @State, @Environment, .task, onChange. Do not introduce a view model just to mirror local state.

  2. Prefer dedicated subview types over computed some View helpers — Flag bodies longer than one screen. Extract private struct SectionName: View with small explicit inputs (data, bindings, callbacks). Keep computed some View helpers rare and small.

  3. Extract actions out of body — No non-trivial inline button actions. No business logic buried in .task, .onAppear, .onChange. Body reads as UI, not as a view controller.

  4. Stable view tree — Avoid top-level if/else branch swapping. Use conditions inside sections/modifiers (overlay, opacity, disabled, toolbar).

  5. View model handling (only if already present) — Make non-optional. Pass dependencies via init. Create in view's init.

  6. Observation — iOS 17+: store @Observable as @State. iOS 16-: @StateObject root, @ObservedObject injected.

Workflow:

  1. Reorder the view to match ordering rules
  2. Remove inline actions/side effects from body
  3. Extract dedicated subview types for long sections
  4. Ensure stable view structure (no top-level conditional swapping)
  5. Standardize view model and observation patterns
  6. Confirm behavior is intact

Splitting threshold: When a view exceeds ~300 lines, split aggressively into dedicated View types.

MCP servers 1

Sponsors

Details

Marketplace
pproenca/dot-claude
Source
plugins/build-ios-apps
Category
Community

More from pproenca/dot-claude

All 6