ios-agent-skills

Manage Claude Code context windows, resume work across sessions, and maintain continuity when your Mac restarts or sessions expire. Use this skill when starting a new session on an existing project, when context feels stale, or when Claude Code starts making mistakes it shouldn't. Prevents the "Claude forgot everything" problem.

Safe patterns for Claude Code interacting with Xcode projects. Covers .pbxproj protection (critical), XcodeBuildMCP build/test patterns, the RenderPreview visual feedback loop, and when to use terminal Claude Code vs Xcode's built-in Claude Agent. Use this skill throughout the entire build process. The .pbxproj rule alone prevents hours of wasted debugging.

Git conventions for parallel Claude Code workstreams in Conductor. Covers branching strategy, merge order, conflict prevention, shared file protection, and the checkpoint pattern. Use this skill throughout the build phase, especially when running multiple Conductor workspaces. Prevents the merge conflicts and corrupted state that kill momentum.

Test every screen in BOTH light and dark mode every iteration. The most common iOS legibility bugs only show in one mode, including a specific class of vibrancy-on-pastel-tint failures that produce illegible labels on glass buttons. Use this skill alongside polish-and-refinement during the polish phase, and as a checklist any time you change colors, tints, or glass surfaces.

How strokes, anti-aliasing, and pixel boundaries actually behave in SwiftUI Canvas and Shape rendering. Covers stroke centering, inset-vs-outset, anti-alias-induced flicker on animating strokes, and 1pt vs 0.5pt strokes on retina displays. Use this skill for any app that draws on a grid or canvas — pattern designers, illustration tools, charting, finger-paint, whiteboards, image editors, gauge / dial UIs.

How to actually prove a UI change works before claiming it does. Covers AX-coordinate snapshots over screenshots, tap-by-label over coordinates, simulator state resets between iterations, and the build → screenshot → AX → math-check loop. Use this skill alongside testing-strategy whenever you're verifying a UI fix on simulator. Required reading before claiming any visual fix is "done."

How to bridge UIKit into a SwiftUI app correctly when SwiftUI's API is genuinely insufficient. Covers UIViewRepresentable lifecycle, sizeThatFits, font-design inheritance, animation suppression, and the small set of legitimate use cases. Use this skill whenever the swiftui-native-first skill points you here for a documented escape hatch.

The single most important quality skill. Enforces native SwiftUI components and rejects unnecessary custom code. Use this skill as a reference throughout the entire build process. Include its core rules in every CLAUDE.md. This is what prevents Claude Code from building janky custom UI when a native component exists.

Take a working app from "it works" to "it feels right." Covers Figma matching, Liquid Glass, animations, haptics, dark mode, and the subjective quality that separates a good app from a great one. Use this skill after all screens are built and data persistence is working. This is where Figma enters the workflow if you designed polished comps.

A living document pattern for capturing iOS platform issues as you discover them. Every time Claude Code hits a wall with an iOS API, a SwiftUI quirk, or a Liquid Glass behavior, add it to your CLAUDE.md immediately so it never happens again. Use this skill at the start of every project to seed known gotchas, and throughout development to capture new ones.

Turn an app vision into the two documents Claude Code needs to build the app - a CLAUDE.md rules file and a screen-by-screen app spec. Use this skill after completing app-vision, when you're ready to set up the project for Claude Code. This produces the contract that governs every Claude Code session.

Everything needed to submit your app to TestFlight and the App Store. Covers bundle ID, icons, screenshots, metadata, TestFlight distribution, and App Store submission. Use this skill when your app passes device testing and you're ready to ship. This is the final phase.

Refine a rough app idea into a clear concept with goals, audience, scope, and core screens. Use this skill when starting a new iOS app from scratch, when you have a vague idea but need structure, or when someone says "I want to build an app that..." This is always the first step before writing any spec or touching Claude Code.

Wire up SwiftData models, queries, and cross-screen state after screens are built with placeholder content. Use this skill when screens look right but have no real data, when you need to define your data models, or when you need to ensure state updates propagate across the app. Typically done as a single focused session after Wave 1-3 of screen building.

Document the visual identity of your app in a format Claude Code can reference. Covers brand colors, typography choices, custom assets, and design tokens. Use this skill when your app has specific brand requirements beyond iOS defaults, when you have Figma designs with a defined visual language, or when you want consistent aesthetics across all screens. Optional for apps that use pure iOS defaults.

Test your app on real devices, catch edge cases, and verify accessibility before shipping. Use this skill after polish is complete and you're preparing for TestFlight or App Store submission. This is the final quality gate before real users touch the app.

Translate Figma designs into SwiftUI code using the Figma MCP, without exporting PNGs or screenshots. Use this skill when you have Figma frames you want Claude Code to match, when you're in the polish phase and want pixel-level accuracy, or when you're adding a new screen that was designed in Figma first. Requires Figma MCP connected to Claude Code.

Set up the complete MCP stack for iOS development with Claude Code. Covers Figma MCP, Sosumi (Apple Docs), XcodeBuildMCP, and Apple's Xcode MCP Bridge. Use this skill when starting a new project, setting up a new machine, or when Claude Code can't access Apple documentation, build your project, or render SwiftUI previews. This is a one-time setup that makes every subsequent session dramatically better.

Everything that happens after v1 ships. Crash reporting setup, TestFlight feedback processing, version management, the update cycle, and how to maintain an app without breaking what already works. Use this skill after your first App Store submission and for all subsequent updates.

Build the complete app skeleton in a single Claude Code session. Every screen exists, all navigation works, but everything uses placeholder content. Use this skill immediately after creating your repo with CLAUDE.md and APP_SPEC.md. This is the one step you CAN one-shot because there's nothing to get wrong -- it's pure structure.

Build one screen at a time with clear descriptions and review cycles. This is the core build loop that takes the most time and produces the most value. Use this skill for every screen after scaffolding is complete. Works perfectly with parallel Conductor workspaces -- each screen is one workspace.

Comprehensive testing approach for iOS apps built with Claude Code. Covers what Claude Code can test automatically (unit tests, build verification), what requires manual testing (interactive behavior, visual feel), and how to set up CI/CD with GitHub Actions. Use this skill during and after the build phase, and especially before shipping. Becomes critical for post-v1 updates where regressions hide.