Core iOS/Swift Development

Swift Coding Specifications

Naming Rules

Type names use UpperCamelCase:
```
class NetworkManager
```
,
```
struct UserProfile
```
Variables/functions use lowerCamelCase:
```
var isLoading
```
,
```
func fetchUser()
```
Bool properties use
```
is
```
/
```
has
```
/
```
should
```
/
```
can
```
prefix:
```
isEnabled
```
,
```
hasPermission
```
Protocols describing capabilities use
```
-able
```
/
```
-ing
```
suffix:
```
Codable
```
,
```
DataProviding
```
; Protocols describing roles use nouns:
```
Delegate
```
Abbreviations: All lowercase if at the start
```
urlString
```
; Two-letter abbreviations are all uppercase if not at the start
```
userID
```
, abbreviations longer than 3 letters capitalize only the first letter
```
userUrl
```

Type Selection

Use struct by default, use class only when reference semantics/inheritance/deinit/ObjC interoperability is required
Use enum + associated value for exhaustive states:
```
case loaded(Data)
```
,
```
case failed(Error)
```
Use enum with no cases for constant namespace:
```
enum Constants { static let timeout = 30.0 }
```

Access Control

Use the strictest level by default:
```
private
```
>
```
fileprivate
```
>
```
internal
```
>
```
public
```
>
```
open
```
Explicitly mark external APIs with
```
public
```
Use
```
private(set)
```
for
```
@Published
```
properties in ViewModel
SwiftUI
```
@State
```
must be marked as
```
private
```

Error Handling

Define domain error enum that conforms to
```
LocalizedError
```
, implement
```
errorDescription
```
Use
```
throws
```
to propagate errors, avoid silent failures
Forbid
```
try!
```
/
```
as!
```
/
```
!
```
in production code, unless there is an absolutely safe reason and a comment is added

Concurrency (async/await)

Prioritize async/await over callbacks or Combine
Use
```
async let
```
for parallel independent tasks
UI updates must be executed on
```
@MainActor
```
Maintain a single write source for simple shared states; hand over complex isolation strategies to
```
swift-expert
```
Mark ViewModel classes with
```
@MainActor
```
Use
```
.task
```
to start asynchronous tasks in SwiftUI View, which will be canceled automatically

Closures

Always use

[weak self]

, then

guard let self else { return }

Use
```
[unowned self]
```
only when you confirm the referenced object has a longer lifecycle

Code Organization

Use
```
// MARK: - Section
```
to partition code
Put Protocol implementations in extensions
Functions should not exceed 40 lines, files should not exceed 400 lines
Use
```
guard
```
for early return, maximum 3 levels of indentation
SwiftUI View body should not exceed 40 lines, extract complex parts as computed properties or sub Views

Comments

Use
```
///
```
document comments for public APIs, including parameter/return value/exception descriptions
Comments explain why, the code itself explains what
Delete commented out code

Project Structure

Default Directory Layout

App/                    → AppDelegate, SceneDelegate, startup configuration
Core/                   → Infrastructure (Network, Storage, Extensions, Utilities)
Features/<FeatureName>/ → Feature modules (Views, ViewModels, Models, Services)
UI/Components/          → Reusable UI components
Resources/              → Assets, Localizable, Info.plist

Architecture Selection

Default for SwiftUI: View + ViewModel (@Observable) + Model + Service
Default for UIKit: MVVM + Coordinator (for medium and above projects)
Use Clean Architecture for complex SDK/large projects: Domain → Data → Presentation

Dependency Injection

Inject through init, do not reference singletons directly
Define Protocol abstraction, inject protocol types
Use
```
@Environment
```
or custom EnvironmentKey for SwiftUI
Inject through Coordinator or init for UIKit

Modularization

Split local modules with SPM
Core module has zero external dependencies
Feature modules depend on Core, do not depend on each other
Each module has an independent Tests target

File Rules

One main type per file, file name matches the type name
Extension files:
```
String+Validation.swift
```
Test files:
```
UserServiceTests.swift
```

SwiftUI Core Rules

State Management

Prioritize
@Observable
over
ObservableObject
(iOS 17+)
```
@State
```
must be marked
```
private
```
, used for states owned by the View
```
@State
```
+
```
@Observable
```
class replaces
```
@StateObject
```
```
@Binding
```
is only used when the child view needs to modify the parent state
```
@Bindable
```
is used when the injected
```
@Observable
```
object needs to be bound
Use
```
let
```
for read-only values, do not use
```
@State
```
or
```
@Binding
```
```
@Observable
```
classes must be marked with
```
@MainActor
```

Modern APIs (Mandatory Usage)

```
foregroundStyle()
```
instead of
```
foregroundColor()
```

clipShape(.rect(cornerRadius:))

instead of

cornerRadius()

```
NavigationStack
```
instead of
```
NavigationView
```
Implement type-safe navigation with
```
navigationDestination(for:)
```
```
Tab
```
API (iOS 18+) instead of
```
tabItem()
```
Dual parameter version of
```
.onChange(of:) { old, new in }
```
Use
```
.task
```
instead of
```
.onAppear
```
to start asynchronous tasks
Use
```
Button
```
instead of
```
onTapGesture
```
(unless position/click count is needed)

Performance Optimization

Only pass specific values needed by the View, avoid passing the entire large object
Avoid redundant state updates in hot paths (check value changes before assignment)
ForEach must use stable ID, forbid
```
.indices
```
(for dynamic content)
Use
```
LazyVStack
```
/
```
LazyHStack
```
for large lists
Avoid inline filtering in ForEach, filter and cache in advance
Keep View body pure, no side effects or complex logic
Hand over complex performance profiling (hot path quantification, copy overhead modeling) to
```
swift-expert
```

Animations

Use
```
.animation(_:value:)
```
instead of the deprecated
```
.animation(_:)
```
Use
```
withAnimation
```
for button clicks
Place animation modifiers after the properties being animated
Use
```
.transition()
```
+
```
withAnimation
```
for transitions

UIKit Core Rules

ViewController Structure

Organize in order: Properties → UI Components → Lifecycle → Setup → Methods → Actions → Protocol Extensions

Layout

Prioritize SnapKit (if available) or
```
NSLayoutConstraint.activate([])
```
Prioritize
```
UIStackView
```
to reduce constraints

Use

UICollectionViewCompositionalLayout

DiffableDataSource

for complex lists

Memory Management

Delegate must be
```
weak
```
Closures capture
```
[weak self]
```
Clean up Timer/observers in deinit

Special References

When learning specific topics in depth, refer to the following detailed guides:

SwiftUI Development - State management, modern APIs, list performance, animations, layout best practices
UIKit Development - ViewController structure, layout, Cell reuse, custom controls
Navigation Architecture - Coordinator Pattern (UIKit), NavigationStack + Router (SwiftUI), deep links
Animation System - SwiftUI animations (implicit/explicit/transition), UIKit animations, performance optimization
Performance Optimization - SwiftUI hot path optimization, UIKit view hierarchy optimization, memory management
Component Design - Custom components, configurable APIs, reusable patterns
Memory Management - Circular references, leak prevention, weak/unowned usage

Relationship with Other Skills

Priority is given to using this skill for default iOS business development
Switch to
```
swift-expert
```
when the task enters any of the following scenarios:
- Requires protocol-oriented deep abstraction (PAT, type erasure, complex generic constraints)
- Requires concurrency isolation design (
```
Sendable
```
  , actor boundaries, reentrancy and cancellation policies)
- Requires in-depth performance and memory profiling based on observable data
- Requires cross-platform (iOS/macOS/watchOS/tvOS) availability difference design

✅ Sentinel (Skill Usage Self-Check)

When and only when you confirm that this Skill has been loaded and applied to the current task, append the following at the end of your reply:

// skill-used: ios-base

Rules:

Output only once
If you are not sure whether it is loaded, do not output the sentinel
Outputting the sentinel means that you have complied with the mandatory rules and delivery format of this Skill
You are allowed to output the sentinel only when the task clearly matches the description of this skill

ios-base

NPX Install

Tags

SKILL.md Content (Chinese)