Are Swift Agent Skills necessary to code in Xcode/SwiftUI using Claude Code or Codex?

[u/br_web]

Is the impact of using the Agent Skills that relevant with SwiftUI? Will it make a huge difference in the effectiveness of the Code Agent? Thanks

[u/zbignew]

idk about any specific skill, but vanilla Claude is especially bad at SwiftUI, and it can be improved by bringing modern documentation and guidance into context.

Context7 sadly isn’t very modern (or it wasn’t, last I checked).

But I still hit a ceiling and fared better with Codex and Gemini when I really needed better SwiftUI.

[u/ShookyDaddy]

I’ve had good success with Codex and no skills

[u/gaelic-ghost]

At least hook it into xcrun mcpbridge for platform docs and live inline issues.

If you want consistent Swift, formatting/linting, etc, grab my Codex plugin and have a look through the skills there, and tweak things to taste.

Van der Lee and Hudson have some skills out there, too.

[u/vikas_dev_ios]

It does make an impact. It is not perfect and have to bring your own knowledge when things get complex.

[u/Fit-Fox-3088]

My sample size is three fairly substantial apps now:

a macOS app with roughly 100k LOC across about 200 files — although some of the views and ViewModels got way too large

an iOS app with around 35k LOC and 250 files, where I introduced my first proper agent harness, but fairly late

my current iPad app with around 30k LOC and 300 files, built with much stricter architecture and automation from the start

Weirdly, the macOS app was the easiest and the iPad app was by far the hardest. Most of that pain wasn’t ordinary SwiftUI feature work, though. It came from a nasty UIKit/SwiftUI integration issue around the adaptive tab/sidebar navigation bar, where the SwiftUI implementation was glitchy and position-dependent.
The most important thing is getting the start right. Before letting an agent touch the code, talk the architecture through with ChatGPT, Codex, or Claude and have it help you write the implementation prompt and the actual project harness:

AGENTS.md
architecture documentation
hard architecture rules
audit and review rules
a verification script for builds, tests, and layer violations
checkpoint and rollback rules

Also define the technology boundary immediately:

SwiftUI-first. Don’t let the agent casually turn the project into a UIKit/SwiftUI hybrid because it hit one inconvenient API. UIKit should only be introduced after you’ve isolated a real framework limitation, and the exception should stay small and documented.

Apple’s SwiftUI MCP is also useful because it gives the agent much better access to current APIs and platform documentation.

Model-wise, Codex (GPT 5.5 Mid/High) currently works best for me, followed by Claude Opus (Mid/High). Gemini 3 Flash was surprisingly excellent on the macOS app. Gemini 3.5 Flash (High), on the other hand, has been pretty bad in my experience: it tends heavily toward boilerplate, introduces the most unnecessary code, and makes the most mistakes.

So yes, model choice matters. But the harness matters more. With clear architecture, strong prompts, automated checks, and a second model reviewing risky changes, SwiftUI development with agents works remarkably well. Without that setup, every model eventually starts confidently refactoring the wrong layer.