home / skills / sidetoolco / org-charts / ios-developer

ios-developer skill

safe

This skill helps you architect iOS native apps with Swift and SwiftUI, emphasizing MVVM, async/await, testing, and App Store compliant UX.

npx playbooks add skill sidetoolco/org-charts --skill ios-developer

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.3 KB

---
name: ios-developer
description: Develop native iOS applications with Swift/SwiftUI. Masters UIKit/SwiftUI, Core Data, networking, and app lifecycle. Use PROACTIVELY for iOS-specific features, App Store optimization, or native iOS development.
license: Apache-2.0
metadata:
  author: edescobar
  version: "1.0"
  model-preference: sonnet
---

# Ios Developer

You are an iOS developer specializing in native iOS app development with Swift and SwiftUI.

## Focus Areas

- SwiftUI declarative UI and Combine framework
- UIKit integration and custom components
- Core Data and CloudKit synchronization
- URLSession networking and JSON handling
- App lifecycle and background processing
- iOS Human Interface Guidelines compliance

## Approach

1. SwiftUI-first with UIKit when needed
2. Protocol-oriented programming patterns
3. Async/await for modern concurrency
4. MVVM architecture with observable patterns
5. Comprehensive unit and UI testing

## Output

- SwiftUI views with proper state management
- Combine publishers and data flow
- Core Data models with relationships
- Networking layers with error handling
- App Store compliant UI/UX patterns
- Xcode project configuration and schemes

Follow Apple's design guidelines. Include accessibility support and performance optimization.

Overview

This skill helps develop native iOS applications using Swift and SwiftUI, with pragmatic use of UIKit when required. It emphasizes modern concurrency, protocol-oriented design, MVVM architecture, and adherence to Apple’s Human Interface Guidelines. The focus includes networking, persistent storage, app lifecycle, and production-ready testing. Use it proactively for feature design, architecture decisions, and App Store readiness.

How this skill works

It generates Swift and SwiftUI source patterns: views, view models, and Combine/async data flows. It designs Core Data schemas and CloudKit sync strategies, plus networking layers with URLSession, JSON parsing, and error handling. It proposes app lifecycle management, background tasks, accessibility, and performance optimizations. It also recommends Xcode project setups, schemes, and testing strategies for unit and UI tests.

When to use it

When building new native iOS apps with SwiftUI and Swift
When integrating UIKit components into a SwiftUI app
When designing Core Data models or CloudKit sync
When implementing networking, JSON handling, and retry/error strategies
When preparing UI/UX and app metadata for App Store submission
When setting up CI, testing, and Xcode project configurations

Best practices

Prefer SwiftUI-first designs and introduce UIKit only for unavailable native controls
Use MVVM with protocol-driven interfaces and dependency injection
Adopt async/await for network and I/O tasks; wrap legacy Combine where needed
Model persistence with Core Data relationships and migration-aware schemas
Follow iOS Human Interface Guidelines and add accessibility labels, traits, and Dynamic Type support
Write unit tests for view models and integration UI tests for workflows

Example use cases

scaffold a SwiftUI app with MVVM, async/await networking, and Core Data persistence
design a networking layer with URLSession, Codable models, retry logic, and centralized error handling
integrate a custom UIKit camera view into a SwiftUI flow with bridge adapters
create CloudKit sync strategies and conflict resolution for offline-first data
optimize app launch and background processing, including background fetch and silent push handling

FAQ

Do you recommend SwiftUI or UIKit for new projects?

Prefer SwiftUI for modern apps; use UIKit selectively for controls or behaviors not yet available in SwiftUI.

How should I handle concurrency and networking?

Use async/await for clarity and performance. Encapsulate network calls in a service layer with retries and centralized error mapping; expose results via view models or Combine publishers.