Skip to main content
skill CX Codex

ios-hig · pproenca — Claude Code skill: Apple HIG for SwiftUI apps

ios-hig — a skill with 34 Apple HIG rules for iOS 26 and Swift 6.2 apps: navigation, gestures, accessibility, loading and error states in SwiftUI.

MIT 310 installs ★ 227 updated 2026-08-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pproenca/dot-skills --skill ios-hig -a claude-code
Open on GitHub

What ios-hig does

The skill turns Apple's Human Interface Guidelines into 34 rules across six groups: navigation, interaction, accessibility, feedback, UX patterns and visual design. Each rule lives in its own file under references/, and the prefixes nav-, inter-, acc-, feed-, ux-, vis- let you aim the agent at one area.

The rules assume a clinic modular MVVM-C project. Feature modules import Domain and DesignSystem only, the App target owns DependencyContainer, the coordinators and route shells, Data implements the Domain protocols, and view models call repositories without a use-case layer in between. Reads follow stale-while-revalidate, writes queue optimistically. On a plain single-target SwiftUI app the architecture half simply will not map onto your code.

Nothing runs by itself here. The agent reads the reference files when you ask it to design a screen or audit one against HIG, and assets/templates/_template.md is the skeleton for adding a rule of your own.

What it helps with

  • Lay out tab bars and NavigationStack hierarchies the way HIG expects
  • Raise tap targets to the 44pt minimum and check gesture handling
  • Wire VoiceOver labels and Dynamic Type through every screen
  • Design loading, error and empty states for a list
  • Run a HIG pass over an app before review

Example prompts for the agent

  • Review CheckoutView against HIG: navigation, touch targets, Dynamic Type.
  • Design the onboarding flow following ux-onboarding and ux-permissions.
  • Rework the empty state of the orders list using feed-empty-states.

How to install ios-hig

1Skills CLI (Vercel)

npx skills add pproenca/dot-skills --skill ios-hig -a claude-code

2Manually: put the files in place

~/.claude/skills/ios-hig/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ios-hig/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about ios-hig

How do I install ios-hig in Claude Code?

Run npx skills add pproenca/dot-skills --skill ios-hig -a claude-code. The skill lands at ~/.claude/skills/ios-hig/SKILL.md.

What does ios-hig do?

It gives the agent 34 Apple HIG rules in six categories: navigation, interaction, accessibility, feedback, UX patterns and visual design. The agent checks SwiftUI screens against them when you ask for a design or a review.

Which architecture do the rules assume?

Clinic modular MVVM-C: features see Domain and DesignSystem only, the App target holds coordinators and DependencyContainer, Data implements Domain protocols, and view models talk to repositories directly.

Source text

SKILL.md · MIT
---
name: ios-hig
description: Apple Human Interface Guidelines for iOS 26 / Swift 6.2 clinic-architecture apps. Covers navigation, interaction design, accessibility, feedback states, UX patterns, and visual design for SwiftUI implementations that follow App-target coordinators/route shells and Domain/Data boundaries. Use when designing or reviewing HIG-compliant experiences in the clinic modular MVVM-C stack.
---

# Apple iOS HIG Best Practices

Comprehensive guide for Apple Human Interface Guidelines compliance in iOS apps built with SwiftUI. Contains 34 rules across 6 categories covering navigation, interaction design, accessibility, user feedback, UX patterns, and visual design.


## Clinic Architecture Contract (iOS 26 / Swift 6.2)

All guidance in this skill assumes the clinic modular MVVM-C architecture:

- Feature modules import `Domain` + `DesignSystem` only (never `Data`, never sibling features)
- App target is the convergence point and owns `DependencyContainer`, concrete coordinators, and Route Shell wiring
- `Domain` stays pure Swift and defines models plus repository, `*Coordinating`, `ErrorRouting`, and `AppError` contracts
- `Data` owns SwiftData/network/sync/retry/background I/O and implements Domain protocols
- Read/write flow defaults to stale-while-revalidate reads and optimistic queued writes
- ViewModels call repository protocols directly (no default use-case/interactor layer)

## When to Apply

Reference these guidelines when:
- Building navigation hierarchies with tab bars, NavigationStack, or split views
- Designing touch interactions, gestures, and haptic feedback
- Ensuring accessibility with VoiceOver, Dynamic Type, and color contrast
- Implementing loading states, error handling, and empty states
- Building onboarding flows, permission requests, and confirmation dialogs
- Supporting dark mode, SF Symbols, and standard layout margins
- Reviewing apps for HIG compliance

## Rule Categories by Priority

| Priority | Category | Impact | Prefix |
|----------|----------|--------|--------|
| 1 | Navigation | CRITICAL | `nav-` |
| 2 | Interaction Design | CRITICAL | `inter-` |
| 3 | Accessibility | CRITICAL | `acc-` |
| 4 | User Feedback | HIGH | `feed-` |
| 5 | UX Patterns | HIGH | `ux-` |
| 6 | Visual Design | HIGH | `vis-` |

## Quick Reference

### 1. Navigation (CRITICAL)

- [`nav-tab-bar`](references/nav-tab-bar.md) - Design tab bars for top-level navigation
- [`nav-navigation-stack`](references/nav-navigation-stack.md) - Use NavigationStack for hierarchical navigation
- [`nav-toolbar-placement`](references/nav-toolbar-placement.md) - Place actions in toolbars using standard placements

### 2. Interaction Design (CRITICAL)

- [`inter-touch-targets`](references/inter-touch-targets.md) - Maintain 44pt minimum touch targets
- [`inter-gesture-patterns`](references/inter-gesture-patterns.md) - Use standard gesture patterns
- [`inter-haptic-feedback`](references/inter-haptic-feedback.md) - Add haptic feedback for meaningful events
- [`inter-keyboard-handling`](references/inter-keyboard-handling.md) - Handle keyboard appearance gracefully
- [`inter-drag-drop`](references/inter-drag-drop.md) - Support drag and drop for content transfer
- [`inter-pull-to-refresh`](references/inter-pull-to-refresh.md) - Support pull to refresh for lists
- [`inter-swipe-actions`](references/inter-swipe-actions.md) - Add swipe actions for contextual operations
- [`inter-list-search`](references/inter-list-search.md) - Use searchable for built-in search

### 3. Accessibility (CRITICAL)

- [`acc-labels`](references/acc-labels.md) - Provide meaningful accessibility labels
- [`acc-dynamic-type`](references/acc-dynamic-type.md) - Support Dynamic Type for all text
- [`acc-color-contrast`](references/acc-color-contrast.md) - Maintain sufficient color contrast
- [`acc-reduce-motion`](references/acc-reduce-motion.md) - Respect reduce motion preference
- [`acc-color-independent`](references/acc-color-independent.md) - Never rely on color alone
- [`acc-focus-management`](references/acc-focus-management.md) - Manage focus for assistive technologies
- [`acc-scaled-metric`](references/acc-scaled-metric.md) - Use ScaledMetric for adaptive sizing
- [`acc-view-that-fits`](references/acc-view-that-fits.md) - Use ViewThatFits for adaptive layouts

### 4. User Feedback (HIGH)

- [`feed-loading-states`](references/feed-loading-states.md) - Show appropriate loading indicators
- [`feed-error-states`](references/feed-error-states.md) - Handle errors with clear recovery actions
- [`feed-notifications`](references/feed-notifications.md) - Use notifications judiciously
- [`feed-success-confirmation`](references/feed-success-confirmation.md) - Confirm successful actions appropriately
- [`feed-empty-states`](references/feed-empty-states.md) - Design helpful empty states

### 5. UX Patterns (HIGH)

- [`ux-onboarding`](references/ux-onboarding.md) - Design minimal onboarding
- [`ux-permissions`](references/ux-permissions.md) - Request permissions in context
- [`ux-modality`](references/ux-modality.md) - Use modality appropriately
- [`ux-confirmation-dialog`](references/ux-confirmation-dialog.md) - Use confirmation dialogs for destructive actions
- [`ux-data-entry`](references/ux-data-entry.md) - Minimize data entry friction
- [`ux-undo`](references/ux-undo.md) - Support undo for destructive actions
- [`ux-settings`](references/ux-settings.md) - Organize settings logically

### 6. Visual Design (HIGH)

- [`vis-dark-mode`](references/vis-dark-mode.md) - Support dark mode with semantic colors
- [`vis-sf-symbols`](references/vis-sf-symbols.md) - Use SF Symbols with correct rendering mode and weight
- [`vis-layout-margins`](references/vis-layout-margins.md) - Use standard layout margins and safe areas

## How to Use

Read individual reference files for detailed explanations and code examples:

- [Section definitions](references/_sections.md) - Category structure and impact levels
- [Rule template](assets/templates/_template.md) - Template for adding new rules

## Reference Files

| File | Description |
|------|-------------|
| [references/_sections.md](references/_sections.md) | Category definitions and ordering |
| [assets/templates/_template.md](assets/templates/_template.md) | Template for new rules |

© pproenca · MIT · pproenca/dot-skills

Similar skills

All skills for Mobile →

ios-hig by other authors comes first.

ios-hig John Rogers (@johnrogers) ios-hig is a Claude Code skill that applies Apple's iOS interface guidance to accessibility, visual design, and interaction. It supports screen creation and control review. CX Codex +1 ★ 233repo stars mobile-ios-design Seth Hobson mobile-ios-design guides native iOS interface work with Apple HIG and SwiftUI patterns. Use it when building views, navigation, or adaptive layouts. CX Codex +1 23,659installs ios-design-guidelines platform-design-skills ios-design-guidelines — a skill for Claude Code, Cursor, Codex, and other agents that loads Apple Human Interface Guidelines rules into iPhone UI tasks. Activates when working with SwiftUI, UIKit, Dark Mode, Dynamic Type, or accessibility. CX Codex +1 2,200installs ios-hig-design wondelai ios-hig-design is a Claude Code skill for designing native iOS interfaces according to Apple's Human Interface Guidelines, covering safe areas, typography, color, navigation, and SF Symbols. CX Codex +1 9,200installs apple-hig-designer jamesrochabrun apple-hig-designer generates native iOS interfaces for iPhone, iPad, and Apple Watch following Apple Human Interface Guidelines. It formats SwiftUI components and validates accessibility. CX Codex +1 1,100installs hig-components-controls raintree-technology hig-components-controls applies Apple HIG principles to pickers, toggles, text fields, and inputs. Guides control selection, state behavior, and VoiceOver accessibility. CX Codex +1 793installs hig-components-content raintree-technology hig-components-content provides Apple Human Interface Guidelines for content components like charts and collections. It helps choose standard controls across Apple platforms. CX Codex +1 779installs

From the same set139

The whole set →
js-google js-google — a skill that feeds your AI agent 47 JavaScript rules from Google's official style guide. Useful when writing, reviewing or refactoring JS. CX Codex +1 323installs tailwind-refactor tailwind-refactor — a skill for refactoring Tailwind CSS classes: migrating from v3 to v4, replacing deprecated utilities and cleaning up code without changing the visual output. CX Codex +1 321installs pulumi A skill with 46 rules for writing and refactoring Pulumi code across supported platforms. Covers state management, resource graph optimization, component design, secrets configuration, and CI/CD automation. CX Codex +1 317installs harness-engineering harness-engineering — a skill for setting up and updating repository infrastructure for AI-driven development. CX Codex +1 312installs rails-testing rails-testing — a set of 46 rules for RSpec, FactoryBot, and Capybara in Ruby on Rails. Guides your AI agent during test generation, reviews, and test suite refactoring. CX Codex +1 309installs ruby-refactor ruby-refactor — a refactoring skill with 45 community guidelines for Ruby projects. Helps agents simplify nested branches, decouple classes, and adopt modern Ruby 3.x patterns. CX Codex +1 307installs ios-xcode ios-xcode is a Claude Code skill for Xcode setup and iOS project tooling. It applies to App-target configuration, SwiftData, testing, debugging, profiling, and app distribution. CX Codex +1 307installs think think — a skill that shifts the AI into deep analysis mode: instead of the first reasonable answer, it finds the highest-leverage solution by connecting ideas across domains. Use it when you need strategy, not instructions. CX Codex +1 307installs

Project sponsors

Companies that keep this analytics open