iPhone Duo Agent Skills

Five coordinated Agent Skills that get SwiftUI and UIKit apps ready for iPhone Duo — the outer display, the regular-by-regular inner display, vertical bars, the hinge, multiple displays and windows, and the two front cameras. They work in any AI coding tool that supports the Agent Skills open format.

The skills turn Apple's six iPhone Duo tech talks, the Designing for iPhone Duo guidelines, the Preparing your app for iPhone Duo guide and Modernize your UIKit app (WWDC26) into a repeatable workflow: measure the project, check what the installed SDK can actually compile, propose a tiered plan where every item cites the session and timestamp (or documentation section) it comes from, and change code only after you approve it.

Website: https://blog.kakoulin.com/apps/iphone-duo-agent-skills

Who this is for

• iOS teams shipping on the iOS 27 / 27.1 SDK who need to know what breaks on iPhone Duo
• Apps with UIScreen.main, orientation or idiom checks that now misbehave in resizable environments — iPhone Duo, iPhone Mirroring on the Mac, iPhone apps on iPad
• Apps whose toolbars should work with iPhone Duo's vertical bars
• Reading, media, camera and creative apps that want to use the fold, the hinge and the outer display well

What it checks

• Launch blockers — app lifecycle without UIScene, which no longer launches with the latest SDK
• Legacy screen assumptions — UIScreen.main, screen bounds as available space, idiom and orientation layout forks, global keyWindow / connectedScenes.first
• Vertical bars — standalone bars the system ignores, item order, titles and symbols, badges, axis behavior, overflow consolidation, visibility priority, compression, opt-out, and hand-built bars that must find the system bar's slot themselves
• Layout — size classes on a regular-width iPhone, standard containers, sidebar placement, asymmetric safe areas, content spanning the fold, displacement, reserved regions, split and overlay arrangements, and what no container moves for you: sheets in folded poses, collection-view sections and WKWebView content
• Displays and scenes — hinge-driven interactions, Split View multitasking, scene requests that fail on the outer display, scene and camera capture accessories
• Cameras — the virtual front camera, cameras that change direction when the device opens or closes, preview mirroring and rotation
• Device assumptions — hard-coded Face ID copy and symbols (iPhone Duo has Touch ID), and whether the app exists in StandBy on the outer display at all (it needs a widget or Live Activity)
• SDK reality — which of those APIs exist in the Xcode you have, what each linked SDK gets on iPhone Duo, where Apple's sample code and the SDK disagree, and which behaviors the iPhone Duo simulator cannot verify at all

Every automated rule is listed with its source in READINESS-CHECKS.md.

Plan before patch

Adapting an app for a new device touches layout everywhere, so the skills treat “make it ready for iPhone Duo” as permission to investigate, not to rewrite.

Before anything changes, you get for every recommendation:

• A stable item ID you can approve
• The finding with file:line
• Why it matters on iPhone Duo
• The Apple session and timestamp it comes from
• Whether the selected SDK can compile it, or which SDK it is blocked on
• Risk, and how to verify it in Device Hub

Nothing is edited until you approve item IDs. Work is applied one tier at a time, rebuilt and rescanned. Poses that could not be run are reported as not run, never as passed.

How it works

Unlike text-only skills, this repository ships two read-only Python scripts, so your agent reasons over structured JSON instead of ad-hoc grep output.

When it triggers:

• You ask to prepare, audit or test an app for iPhone Duo or the foldable iPhone.
• You mention vertical bars, the hinge, reserved regions, ArrangementView, scene accessories, UIScreen.main, orientation or idiom checks, or scene lifecycle migration.
• A build against the iOS 27 or 27.1 SDK shows your layout or toolbars misbehaving on the inner display.

What you can ask:

• Audit this app for iPhone Duo and give me a tiered plan. Don't change anything yet.
• Which of the iPhone Duo APIs can I use with the Xcode I have installed?
• Get rid of UIScreen.main and orientation checks in the Editor module.
• Our toolbar has Select/Done, a compose button and a custom "more" menu — prepare it for vertical bars.
• The floating play button sits on the fold in book pose. Fix it.
• Show a teleprompter on the outer display while recording.

Under the hood:

• scripts/duo_scan.py — walks Swift, Objective-C, Info.plist and build settings. Emits findings with stable IDs, severity, owning skill, session citation and advice, plus an inventory of the containers and APIs the project already uses. Skips dependencies, hidden directories and comments; never writes.
• scripts/sdk_api_check.py — reads the selected SDK's public headers and Swift interfaces and reports which iPhone Duo symbols exist, with their availability annotations. Code is never written against a symbol the compiler cannot see.
• scripts/duo_pose.py — puts a booted iPhone Duo simulator into any pose of the matrix — closed, outer landscape, flat, inner portrait, book or tabletop — and screenshots both displays, for the verification phase. It drives the third-party hinge CLI, 0.3.0 or later (brew install artemnovichkov/tap/hinge), which uses private simulator events; Apple ships no command for it.
• scripts/build_plugin_evals.py — stages the plugin without its evals/ and turns the skill-creator cases into a claude plugin eval suite (CONTRIBUTING.md).
• scripts/probes/ — the programs that produced the measured numbers: a typecheck of every iPhone Duo API shape these skills teach, a geometry probe that reports what a booted iPhone Duo simulator actually returns, and an arrangement probe that shows which views see an ArrangementView's environment values. A toolbar probe shows what each toolbar item reads from toolbarVerticalEdge and how bars compress, and a side-inset probe shows what frees the vertical bar's column and what draws in it. Committed so the figures in references/ can be re-derived rather than trusted.
• Xcode's own modernization skill (xcrun agent skills export) is used for bulk UIKit rewrites when present; these skills cover SwiftUI, bars, the fold and displays.

The skills

Skill	What it does
iphone-duo-readiness	Orchestrator: preflight, scan, SDK check, tiered plan, approval gate, apply through specialists, pose verification
iphone-duo-adaptivity-audit	Scene lifecycle, main screen, screen bounds, idiom, orientation, global window state, Face ID assumptions
iphone-duo-bars	Vertical bars: containers, ordering, titles and symbols, axis, overflow, priority, opt-out
iphone-duo-layout	Size classes, navigation containers, safe areas, corners, reserved regions, displacement, arrangements
iphone-duo-displays	Hinge interactions, Split View multitasking, multiple scenes, scene and camera capture accessories, camera direction, StandBy presence

Start with iphone-duo-readiness for a whole app; call a specialist directly for a focused question. Every skill carries its own copy of the shared references and scripts, so any subset installs cleanly.

How to Use These Skills

Option A: Using skills.sh

Install all five with a single command:

npx skills add https://github.com/alexey1312/iPhone-Duo-Agent-Skill

Or just one:

npx skills add https://github.com/alexey1312/iPhone-Duo-Agent-Skill --skill iphone-duo-bars

Then use it in your AI agent, for example:

Use the iPhone Duo readiness skill and give me a tiered plan for this app.

Option B: Claude Code Plugin

Personal Usage

1. Add the marketplace:

/plugin marketplace add alexey1312/iPhone-Duo-Agent-Skill

2. Install the plugin:

/plugin install iphone-duo-skills@iphone-duo-skills

Project Configuration

To provide the skills to everyone working in a repository, configure the repository's .claude/settings.json:

{
  "enabledPlugins": {
    "iphone-duo-skills@iphone-duo-skills": true
  },
  "extraKnownMarketplaces": {
    "iphone-duo-skills": {
      "source": {
        "source": "github",
        "repo": "alexey1312/iPhone-Duo-Agent-Skill"
      }
    }
  }
}

When team members open the project, Claude Code will prompt them to install the plugin.

Option C: Codex / OpenAI-compatible tools

This repository includes an agents/openai.yaml manifest. Copy or symlink the skill folders into your Codex skills directory:

cp -R skills/iphone-duo-* "$CODEX_HOME/skills/"

See the Codex skills documentation for details on where to save skills.

Option D: Using pi package manager

Install via pi:

pi install https://github.com/alexey1312/iPhone-Duo-Agent-Skill

Option E: Manual install

1. Clone this repository.
2. Install or symlink the folders under skills/ following your tool's official skills installation docs (see links below).
3. Ask your AI tool to use the iphone-duo-readiness skill on your project.

Or download a single .skill archive from the latest release.

Where to Save Skills

• Codex: Where to save skills
• Claude: Using Skills
• Cursor: Enabling Skills

How to verify:

Your agent should run the bundled scan and SDK check first, present a tiered plan with item IDs and session timestamps, and wait for you to approve items before editing. With Xcode 27.0 it should mark iOS 27.1 APIs as blocked; with Xcode 27.1 it should report them as available and name the if #available(iOS 27.1, *) gate they need when your deployment target is lower.

Skill Structure

skills/
  iphone-duo-readiness/         Orchestrator workflow, tiers, approval gate
  iphone-duo-adaptivity-audit/  + references/legacy-api-remediation.md
  iphone-duo-bars/              + references/vertical-bars.md
  iphone-duo-layout/            + references/layout-code.md
  iphone-duo-displays/          + references/displays-code.md
    SKILL.md                    Workflow and rules for the skill
    references/                 sources, api-availability, recommendation-format,
                                pose-test-matrix, device-geometry (shared copies)
    scripts/                    duo_scan.py, sdk_api_check.py (shared copies)
    evals/                      skill-creator evals and fixture projects
references/                     Canonical shared references
scripts/                        Canonical scripts and sync_skill_copies.py
  probes/                       Throwaway programs behind the measured numbers
evals/                          `claude plugin eval` suite for the plugin as a whole
tests/                          Deterministic unit tests
benchmarks/                     skill-creator benchmark results
READINESS-CHECKS.md             Every automated and manual check, with sources

This skill's approach

• Grounded: every recommendation cites an Apple session and timestamp; anything else is labelled as inference.
• SDK-honest: the installed SDK decides what can be written. Talk samples that disagree with it are called out — barMinimizationBehavior versus navigationBarMinimization, UIWindowSceneActivationAction versus UIWindowScene.ActivationAction. It cuts both ways: running the bundled checker against the real 27.1 SDK is what caught it reporting builtInOuterUltraWideCamera as missing when AVFoundation declares it — under an Objective-C name the importer hides.
• Token efficient: one scan returns compact JSON instead of dozens of exploratory searches, and each skill loads only the references it needs.
• Respectful of your decisions: documented, deliberate orientation or idiom reads are reported as kept, not rewritten.
• Safe by design: read-only by default, one tier at a time, rebuild and rescan after every change.

Sources

• Prepare your app for iPhone Duo — Tech Talk
• Raise the bar with iPhone Duo — Tech Talk
• Strike a pose with adaptive layouts on iPhone Duo — Tech Talk
• Leverage multiple displays and scenes on iPhone Duo — Tech Talk
• Build a great camera experience for iPhone Duo — Tech Talk
• Design for iPhone Duo — Tech Talk
• Designing for iPhone Duo — Human Interface Guidelines
• Preparing your app for iPhone Duo — Apple documentation, with the API pages it links (reserved regions, arrangements, hinge, vertical bars, scene accessories)
• Choosing a camera by the direction it faces and Registering a camera capture accessory on iPhone Duo — Apple documentation
• TN3192: Migrating from the deprecated UIRequiresFullScreen key — Apple technote
• TN3208: Preparing your app's launch screen to meet App Store requirements — Apple technote

Chapter-level notes: references/sources.md.

Contributing

Contributions are welcome — especially SDK updates when a new Xcode ships, and false positives found on real projects. Please read CONTRIBUTING.md.

About the author

Created by Aleksei Kakoulin. Packaging follows Antoine van der Lee's Xcode Build Optimization and Xcode Disk Cleanup Agent Skills. iPhone Duo guidance is Apple's; this project is not affiliated with Apple.

License

This project is open-source and available under the MIT License. See LICENSE for details.