Skillget

iPhone-Duo-Agent-Skill

agent
Security Audit
Fail
Health Warn
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 5 GitHub stars
Code Fail
  • rm -rf — Recursive force deletion command in benchmarks/2026-09-13/benchmark.json
Permissions Pass
  • Permissions — No dangerous permissions requested

No AI report is available for this listing yet.

SUMMARY

Agent Skills that audit, plan and adapt SwiftUI & UIKit apps for iPhone Duo — vertical bars, hinge-aware layout, multiple displays — grounded in Apple's sessions and checked against your SDK.

README.md

iPhone Duo Agent Skills — audit, plan and adapt SwiftUI and UIKit apps for Apple's foldable

iPhone Duo Agent Skills

Validate
License: MIT
GitHub Release
GitHub Stars

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
  1. 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

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

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.

Reviews (0)

No results found