Skip to content
Back to search

iphone-duo-skills

Agent skills for building iOS apps on iPhone Duo, Apple's first foldable iPhone — adaptive layout, vertical bars, hinge & scenes, camera, and design review.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/mirzaaghazadeh/iphone-duo-skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/mirzaaghazadeh/iphone-duo-skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mirzaaghazadeh--iphone-duo-skills/badge.svg)](/listings/mirzaaghazadeh--iphone-duo-skills)

HTML

<a href="/listings/mirzaaghazadeh--iphone-duo-skills"><img src="/api/listings/mirzaaghazadeh--iphone-duo-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx skills add mirzaaghazadeh/iphone-duo-skills

Installs all eleven. The CLI detects your agent — Claude Code, Cursor, Copilot, Gemini and others — and puts them where that agent looks.

Useful flags:

# just one skill
npx skills add mirzaaghazadeh/iphone-duo-skills --skill iphone-duo-readiness

# user-level instead of project-level
npx skills add mirzaaghazadeh/iphone-duo-skills --global

# see what's in here without installing
npx skills add mirzaaghazadeh/iphone-duo-skills --list

To try a skill without installing it at all:

npx skills use mirzaaghazadeh/iphone-duo-skills@iphone-duo-readiness

<details> <summary>Manual install</summary>

git clone https://github.com/mirzaaghazadeh/iphone-duo-skills.git
cp -r iphone-duo-skills/skills/* ~/.claude/skills/

Or project-level, into `.claude/skills/` in a repo.

</details>

Each skill is a self-contained `SKILL.md` with YAML frontmatter, so it also works anywhere that reads plain Markdown instructions. Restart the session and the skills appear; invoke one by name or just describe the task.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 262 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # iPhone Duo Skills
  2. [English](README.md) | [简体中文](README_CN.md) | [Français](README_FR.md) | [Türkçe](README_TR.md)
  3. ![iPhone Duo, partially folded, showing the inner display with the dock and controls running vertically down the right side](https://raw.githubusercontent.com/mirzaaghazadeh/iphone-duo-skills/main/assets/iphone-duo-hero.webp)
  4. <sup>Image © Apple Inc., from the [iPhone Duo developer page](https://developer.apple.com/iphone-duo/), used for identification. Not affiliated with or endorsed by Apple.</sup>
  5. Agent skills for building iOS apps on **iPhone Duo** — Apple's first foldable
  6. iPhone, announced September 9, 2026.
  7. Apple's developer material for iPhone Duo is now six Tech Talk videos, the
  8. [Designing for iPhone Duo](https://developer.apple.com/design/human-interface-guidelines/designing-for-iphone-duo)
  9. HIG page, the [Prepare](https://developer.apple.com/iphone-duo/prepare/)
  10. checklist, and the API reference. The last two landed after this repo started —
  11. the API reference corrected three claims, and the Prepare guide added several
  12. more. Both passes are reflected here.
  13. These skills distill all of it into structured guidance an agent can act on,
  14. plus reference sheets for device facts and the full API surface.
  15. ## Install
  16. ```bash
  17. npx skills add mirzaaghazadeh/iphone-duo-skills
  18. ```
  19. Installs all eleven. The CLI detects your agent — Claude Code, Cursor, Copilot,
  20. Gemini and others — and puts them where that agent looks.
  21. Useful flags:
  22. ```bash
  23. # just one skill
  24. npx skills add mirzaaghazadeh/iphone-duo-skills --skill iphone-duo-readiness
  25. # user-level instead of project-level
  26. npx skills add mirzaaghazadeh/iphone-duo-skills --global
  27. # see what's in here without installing
  28. npx skills add mirzaaghazadeh/iphone-duo-skills --list
  29. ```
  30. To try a skill without installing it at all:
  31. ```bash
  32. npx skills use mirzaaghazadeh/iphone-duo-skills@iphone-duo-readiness
  33. ```
  34. <details>
  35. <summary>Manual install</summary>
  36. ```bash
  37. git clone https://github.com/mirzaaghazadeh/iphone-duo-skills.git
  38. cp -r iphone-duo-skills/skills/* ~/.claude/skills/
  39. ```
  40. Or project-level, into `.claude/skills/` in a repo.
  41. </details>
  42. Each skill is a self-contained `SKILL.md` with YAML frontmatter, so it also works
  43. anywhere that reads plain Markdown instructions. Restart the session and the
  44. skills appear; invoke one by name or just describe the task.
  45. ## The skills
  46. | Skill | Works with | Use it when |
  47. |---|---|---|
  48. | **iphone-duo-readiness** | SwiftUI · UIKit | Entry point. Auditing or porting an existing app — SDK tiers, fixed-assumption hunting, safe areas, routing to the rest. |
  49. | **iphone-duo-adaptive-layout** | SwiftUI · UIKit | Content lands in the fold. Reserved regions, division vs occlusion, displacement patterns, `ArrangementView`. |
  50. | **iphone-duo-vertical-bars** | SwiftUI · UIKit | Toolbars and tab bars. The vertical axis, symbol vs text, `AxisBehavior`, overflow and visibility priority. |
  51. | **iphone-duo-hinge-and-scenes** | SwiftUI · UIKit | Hinge-driven effects, Split View, multiple scenes, dual-display UI via scene accessories. |
  52. | **iphone-duo-camera** | AVFoundation · AVKit | Capture apps. Virtual front camera vs individual cameras, direction coordinator, mirroring, preview. |
  53. | **iphone-duo-dual-pane-patterns** | SwiftUI · UIKit | Deciding what goes in each pane. Pixel/point dimensions, safe-area and layout tokens, exact hinge callback types, pose → pattern mapping, hinge-driven effects, two-pane paywalls, fold-aware onboarding. |
  54. | **iphone-duo-design-review** | Any framework | Design critique rather than code — poses, side controls, asymmetry, fold avoidance, sheets. |
  55. | **iphone-duo-games** | Unity · Unreal · Godot · SpriteKit · Metal | The project is a game. Filling the screen across poses, aspect ratio vs letterboxing, touch controls clear of the fold. |
  56. | **iphone-duo-flutter** | Flutter · Dart | The app is Flutter. What `MediaQuery` gives you, why `displayFeatures` doesn't work here, bridging via platform channels. |
  57. | **iphone-duo-react-native** | React Native · Expo | The app is React Native. Asymmetric insets, resize handling, bridging via a native module. |
  58. | **iphone-duo-capacitor** | Capacitor · Ionic · Angular · React · Vue | The app runs in a web view. Why Device Posture and Viewport Segments do not reach it, safe-area asymmetry, and getting fold state from the native side. |
  59. ### Which skills apply to your stack
  60. **Native iOS — SwiftUI or UIKit.** Start with `iphone-duo-readiness`, which routes
  61. you to the rest. The five Swift-focused skills name real iOS 27.1 APIs you can
  62. call directly; `iphone-duo-design-review` applies whatever you build in.
  63. **Flutter.** Read `iphone-duo-flutter` first, then `iphone-duo-design-review` —
  64. the design guidance is framework-neutral and applies unchanged. Skim
  65. `iphone-duo-adaptive-layout` for the *reasoning* behind reserved regions and
  66. displacement; the concepts transfer even though the code doesn't.
  67. **React Native or Expo.** Same shape: `iphone-duo-react-native`, then
  68. `iphone-duo-design-review`, then `iphone-duo-adaptive-layout` for background.
  69. **Any framework, if you capture photo or video.** `iphone-duo-camera` matters
  70. regardless of stack, because the two front cameras and the "which way is this
  71. camera facing" problem are AVFoundation-level facts. Cross-platform apps hit them
  72. through whatever camera plugin they use, or through their own bridge.
  73. **Games — Unity, Unreal, Godot, SpriteKit, Metal.** Read `iphone-duo-games`. Games
  74. sidestep most of the UI guidance but not resizing, and the fold is a genuine
  75. hazard for on-screen touch controls.
  76. **Capacitor, Ionic or another web view.** Read `iphone-duo-capacitor` first,
  77. then `iphone-duo-design-review`. The twist there is that the standard web APIs
  78. for this exist but are flagged off in a `WKWebView`, so the fold has to come
  79. from the native side even though the CSS for it is specified.
  80. **Kotlin Multiplatform, .NET MAUI and friends.** No dedicated skill,
  81. but the pattern from the Flutter and React Native skills carries over directly:
  82. everything is either *resize and safe-area handling you can do in your existing
  83. layer*, or *a native bridge to the iOS 27.1 APIs*. Read whichever cross-platform
  84. skill is closer to your setup, plus `iphone-duo-design-review`.
  85. > **Cross-platform reality check.** Neither Flutter nor React Native supports
  86. > iPhone Duo yet. Flutter's `MediaQuery.displayFeatures` is documented as
  87. > populated **only on Android**, so it returns an empty list here; React Native has
  88. > no fold API at all. Both skills split what works today from what needs a native
  89. > bridge, so you don't lose an afternoon hunting for an API that isn't there.
  90. ## Reference
  91. - [`reference/device-facts.md`](reference/device-facts.md) — displays (pixels,
  92. ppi, points), dimensions, silicon, cameras, poses, and the size-class table
  93. - [`reference/api-index.md`](reference/api-index.md) — every announced API by
  94. job, with framework and minimum SDK
  95. - [`reference/sources.md`](reference/sources.md) — every source, linked
  96. ## What actually matters on this device
  97. If you read nothing else:
  98. **iPhone Duo is not a new idiom — it's a wider continuum of sizes.** Every bug in
  99. a foldable port comes from an app asserting something fixed (this idiom, this
  100. orientation, this screen, this width, this symmetric inset), and every fix
  101. replaces that assertion with a question about the space available right now.
  102. <picture>
  103. <source media="(prefers-color-scheme: dark)" srcset="assets/layout-model-dark.svg">
  104. <img alt="Three device states — closed on the 5.4-inch outer display (compact by regular, bars move to the side), partially folded with a division region down the centre of the inner display (regular by regular, keep touch targets out of the curve), and open flat on the 7.6-inch inner display (regular by regular, room for a split view). Below, the chain: pose, available space, size class, what the system moves." src="assets/layout-model.svg" width="900">
  105. </picture>
  106. <sup>Diagram by this project. The underlying behavior is documented across Apple's
  107. [iPhone Duo Tech Talks](https://developer.apple.com/iphone-duo/) and
  108. [Designing for iPhone Duo](https://developer.apple.com/design/human-interface-guidelines/designing-for-iphone-duo);
  109. see [`reference/sources.md`](reference/sources.md).</sup>
  110. Three concrete consequences:
  111. 1. **The inner display ignores your supported interface orientations.** Branch on
  112. size class, never on orientation or idiom.
  113. 2. **`UIScreen.main` is ambiguous here** and slated for deprecation. Use the
  114. environment, the trait collection, or the scene's bounds.
  115. 3. **Safe areas are asymmetric.** Any math shaped like
  116. `width - safeAreaInsets.left * 2` is a defect.
  117. And the highest-leverage single change: **build against the iOS 27.1 SDK.**
  118. It's the gate for edge-to-edge content, vertical bars, reserved regions and
  119. arrangements.
  120. ## Accuracy
  121. Every technical claim traces to Apple's Tech Talks, the *Designing for iPhone Duo*
  122. HIG page, the published API reference, or the Newsroom announcement.
  123. **Verified against Apple's API reference on 25 September 2026.** The symbol docs
  124. are now live, so the signatures in `reference/api-index.md` come from them rather
  125. than from the Tech Talk sessions. That pass corrected three things that had been
  126. wrong:
  127. - The direction coordinator's change handler receives an
  128. `AVCaptureDeviceDirectionMap`, not an `AVCaptureDeviceDescriptor` — it hands you
  129. *arrays* of forward- and backward-facing descriptors to choose from.
  130. - The UIKit arrangement mutators take an `animated:` parameter. (It defaults to
  131. `false`, the October pass found, so the Tech Talks' shorter calls compile —
  132. they just don't animate.)
  133. - `toolbarVerticalEdge` reports the system's preferred edge **whether or not a
  134. vertical bar is visible** — it isn't a "are items vertical right now" flag.
  135. A second pass on **27 September 2026** covered the hinge types and the SwiftUI
  136. reserved-region query, and corrected three more:
  137. - UIKit's `UIHinge.angle` is in **radians**, and `UIHinge.Status` has a fourth
  138. case, `.unknown`. SwiftUI's `DeviceHinge.Status` is a struct, not an enum.
  139. - The SwiftUI `reservedRegions` query takes a `layoutDirectionBehavior:`
  140. parameter (default `.mirrors`).
  141. - A reserved region's `frame` **already includes** its `margins` — they aren't
  142. extra padding to add around it.
  143. A third pass on **23 October 2026**, after Apple expanded the reserved-region and
  144. arrangement pages into full articles, settled one question and opened another:
  145. - The region query returns **only active regions** by default. The September
  146. reference had read otherwise; it now agrees with the Tech Talks.
  147. - The Tech Talk says a flat fold is inactive with zero width; the reference and
  148. Group Lab Day 3 now say an inactive region keeps a frame you can leave room for
  149. ahead of time. The skills follow the later sources, with a note to check the
  150. frame in the simulator.
  151. - A split arrangement shows **only its primary view** on a closed iPhone Duo held
  152. in landscape, and along any axis you excluded.
  153. A fourth pass on **30 October 2026** read *Registering a camera capture accessory
  154. on iPhone Duo*, which the docs watcher had been looking for at the wrong path,
  155. and corrected one more:
  156. - UIKit has **no `CameraCaptureAccessory`**. It registers a
  157. `UISceneAccessory.cameraCapture(sceneConfiguration:userInfo:)` on the view
  158. controller and gets back a `UISceneAccessoryRegistration` to observe and
  159. toggle.
  160. A fifth pass on **6 November 2026** diffed every page the watcher flagged
  161. against an archived copy. Apple had only reordered text or added links, but the
  162. pass filled two gaps:
  163. - `toolbarVerticalEdge` is `nil` only where the system never places a vertical
  164. bar. The bar keeps its physical side in right-to-left languages, so its
  165. `.leading` / `.trailing` value changes with the locale.
  166. - Tech Talk 111465 now links *Supporting device rotation in your camera app*. A
  167. rotation coordinator is bound to one camera, so each camera switch a fold
  168. causes needs a new one.
  169. Corrections and open conflicts are marked ⚠ in the API index.
  170. `scripts/fetch-transcripts.py` re-fetches the Tech Talk transcripts from the
  171. WebVTT subtitle track in each video's HLS manifest, which is how this repo was
  172. researched. Re-run it when `scripts/check-sources.py` reports a new session.
  173. ## Maintenance
  174. Three workflows keep this honest, since the main risk to a repo like this is
  175. drifting out of date without anyone noticing.
  176. | Workflow | Runs | Does |
  177. |---|---|---|
  178. | `validate.yml` | every push and PR | Checks every `SKILL.md` has valid frontmatter, that `name` matches its directory and is unique, that cross-references resolve, and that the npm package still builds |
  179. | `watch-apple-docs.yml` | Fridays, 06:00 UTC | Diffs 33 Apple pages — the landing page, Prepare checklist, HIG, API reference, articles and sessions — and opens (or comments on) an issue labelled `apple-docs` when something changes |
  180. | `publish.yml` | on a GitHub release | Validates, checks the tag matches `package.json`, then publishes to npm with provenance |
  181. Both scripts run locally too:
  182. ```bash
  183. python3 scripts/validate-skills.py # same checks CI runs
  184. python3 scripts/check-sources.py # refresh the Apple docs baseline
  185. ```
  186. The watcher also reads the links on Apple's iPhone Duo landing page, the
  187. references in the *Preparing your app for iPhone Duo* article and each
  188. session's Resources list, and reports any page it doesn't track as
  189. **UNTRACKED** — guessed URLs have missed a published
  190. article twice. Its state lives in `.github/sources-state.json`.
  191. `publish.yml` needs an `NPM_TOKEN` secret. Because this account requires 2FA for
  192. publishing, an ordinary automation token won't work — it needs a **granular
  193. access token with "bypass 2FA" enabled**, scoped to this package.
  194. ## License
  195. MIT — see [LICENSE](LICENSE).
  196. Not affiliated with or endorsed by Apple. "iPhone" and "iPhone Duo" are
  197. trademarks of Apple Inc.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.