ios-design-guidelines

Overview of ios-design-guidelines skill

The ios-design-guidelines skill helps you check, shape, and rewrite iPhone UI work against Apple Human Interface Guidelines without reading the full source first. It is most useful for SwiftUI and UIKit tasks where layout, navigation, accessibility, Dynamic Type, Dark Mode, or system component choices can make or break the result.

Use this ios-design-guidelines skill when you need practical guidance for a real interface decision, not abstract design theory. It is a good fit for designers, iOS engineers, and review agents that need to catch avoidable HIG mistakes fast: tiny tap targets, unsafe layouts, nonstandard navigation, hardcoded text sizes, or missing accessibility support.

What this skill is best for

The primary job-to-be-done is translating a rough UI idea into an iPhone-appropriate implementation or review checklist. The skill is strongest when you want Apple-aligned defaults, examples in SwiftUI/UIKit, and concrete rule checks rather than generic “make it intuitive” advice.

Where it adds real value

It is especially helpful when you are deciding between common iOS patterns: tab bar vs. custom navigation, safe-area behavior, bottom-anchored actions, text scaling, semantic colors, and system gestures. That makes the ios-design-guidelines guide more decision-oriented than a quick skim of the repo.

When it is not a fit

If you need broad product strategy, cross-platform design advice, or Android/web patterns, this skill is the wrong source of truth. It is also less useful for purely visual branding work that does not depend on iOS conventions.

How to Use ios-design-guidelines skill

Install and inspect the right files

Install with npx skills add ehmo/platform-design-skills --skill ios-design-guidelines. For the ios-design-guidelines install to pay off, read SKILL.md first, then AGENTS.md, metadata.json, and rules/_sections.md. Those files show the skill’s scope, rule priorities, and the few rule groups you are most likely to apply.

Turn a vague goal into a usable prompt

The best ios-design-guidelines usage starts with a specific interface context. Include platform, screen type, user task, and current risk. For example: “Review this SwiftUI checkout screen for iPhone, focusing on thumb-zone placement, safe areas, touch targets, and Dynamic Type. Suggest only changes that preserve the current flow.” That gives the skill something actionable instead of a generic “improve my app.”

What input improves output quality

Provide the relevant UI excerpt, component list, and constraints: iPhone-only or universal, SwiftUI or UIKit, supported iOS version, and any must-keep behaviors. If you are asking for a rewrite, include the current code or screen structure so the skill can map rules to actual controls instead of guessing.

Practical workflow to follow

Start with a focused review pass, then ask for a narrower second pass on any risky area: navigation, accessibility, or layout. For example, first ask for the highest-priority HIG violations, then ask for a corrected implementation of just the top three issues. This keeps the ios-design-guidelines usage efficient and makes fixes easier to apply.

ios-design-guidelines skill FAQ

Is this only for SwiftUI?

No. The ios-design-guidelines skill covers both SwiftUI and UIKit, so it works for new builds and legacy refactors. Use it to compare implementation choices against iPhone conventions, not just to generate code.

How is this different from a normal prompt?

A normal prompt often produces surface-level UI advice. This skill is built around Apple-specific rules and common failure modes, so the ios-design-guidelines guide is better when you need reviewable, iPhone-native recommendations with less guesswork.

Do I need to be an iOS expert to use it?

No. Beginners can use it well if they describe the screen clearly and provide the code or layout they already have. The main limitation is input quality: if the prompt is vague, the output will be vague too.

When should I avoid using it?

Skip it for non-iPhone interfaces, brand-only mockups, or cases where you explicitly want to break standard iOS behavior. If your goal is a novel interaction pattern, the ios-design-guidelines skill may correctly push you back toward system conventions.

How to Improve ios-design-guidelines skill

Give the skill the rule context it needs

The best results come when you identify which parts of the interface are most likely to fail HIG review. Mention whether you care most about layout, navigation, typography, color, or accessibility so the ios-design-guidelines skill can weight its feedback instead of spreading attention too thin.

Ask for changes, not just commentary

If you want implementation help, ask for a revised screen structure, corrected SwiftUI/UIKit code, or a prioritized fix list. The skill is more useful when it can turn a problem into an explicit action, such as raising touch targets, moving primary actions into the thumb zone, or restoring safe-area compliance.

Watch for common failure modes

The biggest misses are usually custom navigation that fights iOS, text that does not scale, and visual-only state cues that fail accessibility. If your first pass looks too generic, add concrete constraints like “must preserve current navigation” or “must support extra-large Dynamic Type” to force better ios-design-guidelines usage.

Iterate with a narrower second prompt

After the first answer, re-run the skill on the most important risk area rather than asking for another full review. For example: “Now check only accessibility for VoiceOver, Reduce Motion, and contrast.” That produces sharper feedback and makes the ios-design-guidelines install more valuable on real projects.