Search the docs, videos, blog, apps, teams, skills and release notes.
At a glance
What it is
Expert iOS/Swift development covering SwiftUI patterns, UIKit integration, Combine/async-await, Core Data, networking, push notifications, App Store guidelines, signing/provisioning, and performance instruments.
A skill is a written procedure a bot loads when a job calls for it. This one is a single file, SKILL.md, and the whole file is on this page.
The whole file, exactly as it downloads. Read it before you rely on it.
SKILL.md
426 lines · 1,591 words
This skill provides comprehensive expertise in building production-quality iOS applications using Swift. It covers modern SwiftUI-first development, UIKit interoperability, structured concurrency, data persistence, networking, push notifications, App Store compliance, and performance analysis with Instruments.
Expert iOS/Swift development covering SwiftUI patterns, UIKit integration, Combine/async-await, Core Data, networking, push notifications, App Store guidelines, signing/provisioning, and performance instruments.
Nothing. It ships with Murage, which is open source. Your bots run on the AI plan you already have.
Yes. Open it in Settings → Skills to read, edit or duplicate it. Skill Guard scans it again after every edit.
Download the app, connect the AI you already pay for, and tell your Chief of Staff what needs doing. Plan on about ten minutes from install to a working team.
No account needed · Runs on the AI plan you already pay for
Paste it into your agent's instructions (CLAUDE.md, AGENTS.md or a custom GPT), or add it to a bot in Murage.
Ask Ember for the bot, then switch the skill on in its settings.
Step 1
Send your Chief of Staff this message. It proposes the bot and its role first, and creates it when you say go.
Send this to Ember
“Create a bot that uses the iOS Developer skill, and show me the plan first.”
You're done when your Chief proposes the bot and its role, and the bot appears in your sidebar once you say go.
Step 2
You're done when you see the bot’s skills and the library.
Step 3
You're done when the skill shows as on for that bot.
Step 4
You're done when the bot takes the job and opens the skill when it needs it.
Prefer to do it yourself? Choose + in the sidebar, then New Bot.Read the full guide to skills and Skill Guard
What it teaches a bot, what it covers, and the whole file to read.
What it covers
Overview
SwiftUI Architecture Patterns
SwiftUI + UIKit Integration
Structured Concurrency (async/await)
Core Data with SwiftUI
Networking with URLSession
Push Notifications (APNs)
Signing and Provisioning
App Store Review Guidelines Summary
Performance with Instruments
Production Checklist
When to Use
Output Format
Example
Edge Cases
// Model
struct Product: Identifiable, Codable {
let id: UUID
var name: String
var price: Decimal
var category: Category
var imageURL: URL?
}
// ViewModel (iOS 17+ with @Observable)
@Observable
class ProductListViewModel {
var products: [Product] = []
var searchText = ""
# ... (condensed) ...
Alert(title: Text("Error"), message: Text(error.message))
}
}
}
}// Protocol-based DI
protocol ProductRepository: Sendable {
func fetchAll() async throws -> [Product]
func get(id: UUID) async throws -> Product
func save(_ product: Product) async throws
func delete(_ id: UUID) async throws
}
// Live implementation
struct LiveProductRepository: ProductRepository {
let apiClient: APIClient
func fetchAll() async throws -> [Product] {
try await apiClient.request(.get, "/products")
# ... (condensed) ...
}
extension ProductRepository where Self == MockProductRepository {
static var mock: MockProductRepository { MockProductRepository() }
}// UIViewRepresentable for UIKit views
struct MapView: UIViewRepresentable {
@Binding var region: MKCoordinateRegion
var annotations: [MKAnnotation]
func makeUIView(context: Context) -> MKMapView {
let mapView = MKMapView()
mapView.delegate = context.coordinator
return mapView
}
func updateUIView(_ mapView: MKMapView, context: Context) {
mapView.setRegion(region, animated: true)
mapView.removeAnnotations(mapView.annotations)
# ... (condensed) ...
func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
parent.region = mapView.region
}
}
}class SettingsViewController: UIViewController {
supersede func viewDidLoad() {
super.viewDidLoad()
let settingsView = SettingsView(viewModel: SettingsViewModel())
let hostingController = UIHostingController(rootView: settingsView)
addChild(hostingController)
view.addSubview(hostingController.view)
hostingController.view.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
hostingController.view.topAnchor.constraint(equalTo: view.topAnchor),
hostingController.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
hostingController.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
hostingController.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
])
hostingController.didMove(toParent: self)
}
}// Global actor for database operations
@globalActor actor DatabaseActor {
static let shared = DatabaseActor()
}
// Actor-isolated repository
actor ProductStore {
private var cache: [UUID: Product] = [:]
private let persistence: PersistenceController
init(persistence: PersistenceController = .shared) {
self.persistence = persistence
}
# ... (condensed) ...
products: products,
categories: categories,
promotions: promotions
)
}extension Publisher {
func firstValue() async throws -> Output {
try await withCheckedThrowingContinuation { continuation in
var cancellable: AnyCancellable?
cancellable = self.first()
.sink(
receiveCompletion: { completion in
if case .failure(let error) = completion {
continuation.resume(throwing: error)
}
cancellable?.cancel()
},
receiveValue: { value in
continuation.resume(returning: value)
cancellable?.cancel()
}
)
}
}
}class PersistenceController {
static let shared = PersistenceController()
static let preview: PersistenceController = {
let controller = PersistenceController(inMemory: true)
// Seed preview data
let context = controller.container.viewContext
for i in 0..<10 {
let product = ProductEntity(context: context)
product.id = UUID()
product.name = "Product \(i)"
product.price = Decimal(Double.random(in: 9.99...99.99))
}
try? context.save()
return controller
# ... (condensed) ...
List(products) { product in
Text(product.name ?? "Unknown")
}
}
}enum HTTPMethod: String {
case get = "GET"
case post = "POST"
case put = "PUT"
case delete = "DELETE"
}
struct APIClient {
static let shared = APIClient()
private let session: URLSession
private let decoder: JSONDecoder
private let baseURL: URL
init(session: URLSession = .shared, baseURL: URL = AppConfig.apiBaseURL) {
# ... (condensed) ...
let errorBody = try? decoder.decode(APIErrorResponse.self, from: data)
throw APIError.server(httpResponse.statusCode, errorBody?.message)
}
}
}// AppDelegate setup
class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {
func application(
_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
UNUserNotificationCenter.current().delegate = self
registerForPushNotifications()
return true
}
func registerForPushNotifications() {
UNUserNotificationCenter.current().requestAuthorization(
options: [.alert, .badge, .sound, .provisional]
# ... (condensed) ...
if let deepLink = userInfo["deep_link"] as? String {
DeepLinkRouter.shared.navigate(to: deepLink)
}
}
}Signing Setup:
├── Development
│ ├── Automatic Signing: ON (let Xcode manage)
│ ├── Team: Your Apple Developer Team
│ └── Xcode creates dev provisioning profile automatically
├── CI/CD Build
│ ├── Manual Signing recommended
│ ├── Download certificates from Apple Developer portal
│ ├── Install via Fastlane Match (shared team signing)
│ └── Store in CI secrets / keychain
├── TestFlight Distribution
│ ├── Requires App Store distribution certificate
│ ├── Provisioning Profile: App Store type
│ └── Upload via Xcode, Transporter, or `xcrun altool`
└── App Store Release
├── Same certificate as TestFlight
├── Archive → Upload → App Store Connect review
└── Typically automated via Fastlane or Xcode Cloud# Matchfile
git_url("[reference URL]")
storage_mode("git")
type("appstore")
app_identifier(["com.myapp.ios", "com.myapp.ios.widget"])
username("apple-id@company.com")
team_id("ABC123XYZ")
# Fastfile
lane :beta do
match(type: "appstore")
build_app(scheme: "MyApp", export_method: "app-store")
upload_to_testflight(skip_waiting_for_build_processing: true)
end| Rejection Reason | Guideline | Prevention |
|---|---|---|
| Crashes / Bugs | 2.1 | Test on all supported devices and OS versions |
| Broken links | 2.1 | Verify all URLs before submission |
| Placeholder content | 2.3.3 | Remove all lorem ipsum and test data |
| Incomplete metadata | 2.3 | Fill all App Store Connect fields |
| Privacy violations | 5.1.1 | Declare all data collection in privacy nutrition labels |
| Missing login credentials | 2.1 | Provide demo account in review notes |
| In-app purchase bypass | 3.1.1 | Use StoreKit for all digital goods |
| Misleading screenshots | 2.3.7 | Screenshots must reflect actual app experience |
| Instrument | Diagnoses | When to Use |
|---|---|---|
| Time Profiler | CPU bottlenecks | Slow operations, high CPU |
| Allocations | Memory usage | Growing memory footprint |
| Leaks | Retain cycles | Memory warnings, OOM crashes |
| Core Animation | Rendering perf | Choppy scrolling, dropped frames |
| Network | HTTP traffic | Slow loads, excessive requests |
| Energy Log | Battery drain | Background tasks, location use |
// 1. Avoid main thread blocking
// BAD
let data = try Data(contentsOf: fileURL) // blocks main thread
// GOOD
Task.detached(priority: .userInitiated) {
let data = try Data(contentsOf: fileURL)
await MainActor.run { self.processData(data) }
}
// 2. Image optimization
// BAD: Loading full-res images in a list
Image(uiImage: UIImage(contentsOfFile: path)!)
# ... (condensed) ...
) { [weak self] _ in
self?.onUpdate?()
}
}
}Set minimum deployment target (typically current - 2)
Configure App Transport Security exceptions (if needed)
Implement proper error handling with user-facing messages
Add Crashlytics or equivalent crash reporting
Set up automated UI tests via XCUITest
Configure Xcode Cloud or Fastlane for CI/CD
Complete App Store Connect metadata and screenshots
Declare privacy nutrition labels accurately
Test VoiceOver accessibility
Profile with Instruments (Time Profiler, Leaks, Allocations)
Verify universal link / deep link configuration
Test push notifications in production APNs environment
Validate in-app purchases in sandbox
Enable Bitcode (if required by dependencies)
Archive and validate before submission
Use this skill when:
Designing or implementing ios developer solutions
Reviewing or improving existing ios developer approaches
Making architectural or implementation decisions about ios developer
Learning ios developer patterns and best practices
Troubleshooting ios developer-related issues
Do NOT use this skill when:
The question is about a fundamentally different technology domain
A more specific sibling skill covers the exact topic needed
The user needs a complete hands-on tutorial rather than expert guidance
# Ios Developer Analysis
## Context Assessment
[Situation summary and constraints]
## Recommended Approach
[Primary recommendation with rationale]
## Implementation Steps
1. [Step with specific details]
2. [Step with specific details]
3. [Step with specific details]
## Trade-offs and Considerations
- [Key trade-off 1]
- [Key trade-off 2]
## Next Steps
- [Immediate action item]
- [Follow-up action item]Input: "Help me implement ios developer for a medium-scale production application"
Output: A structured analysis covering current state assessment, recommended ios developer approach with specific patterns, implementation roadmap with milestones, and risk mitigation strategies tailored to the application scale and constraints.
Legacy system integration: When ios developer must coexist with legacy approaches, provide a gradual migration path rather than a complete rewrite
Scale mismatch: When the solution complexity exceeds the project scale, recommend a simpler approach and note when to revisit
Team skill gaps: When the team lacks experience with the recommended approach, include learning resources and simpler alternatives
Conflicting requirements: When constraints conflict (e.g., performance vs. maintainability), explicitly state the trade-off and recommend based on stated priorities
SKILL.md
426 lines · 1,591 words
The text of SKILL.md is shown as it downloads, under the Apache-2.0 license, by Ferrox Labs. The license is the one in the file's own frontmatter.
Your new bot
iOS Developer bot
Waiting in your sidebar once you say go.
No account needed · Runs on the AI plan you already pay for