How to Build iOS Apps Using OpenAI Plugins: Complete Guide to Codex Skills and MCP Integration

The OpenAI plugins repository provides a dedicated "Build iOS Apps" plugin that enables Codex to generate SwiftUI code, debug via Xcode simulator, profile performance with ETTrace, and create App Intents through specialized skills and MCP server integration.

To build iOS apps using OpenAI plugins, developers leverage the plugins/build-ios-apps directory in the openai/plugins repository. This plugin bundles nine specialized skills—ranging from SwiftUI pattern generation to memory leak detection—accessed through a Codex manifest and MCP configuration that bridges the assistant directly with Xcode workflows.

Understanding the Build iOS Apps Plugin Architecture

The plugin architecture centers on two configuration files that declare capabilities to the Codex environment.

In plugins/build-ios-apps/.codex-plugin/plugin.json, the plugin manifest defines the skill directory structure and metadata. This file points Codex to the local skill implementations and registers the plugin within the marketplace. The companion .mcp.json file configures the Model Context Protocol (MCP) server, specifically wiring the Xcode-Build-MCP for simulator control, build operations, and debugging sessions.

When activated, the assistant reads these configurations to invoke shell commands, generate code from reference patterns, and stream simulator logs back to the development environment.

Core Skills for iOS Development

The plugin organizes functionality into discrete skills residing under plugins/build-ios-apps/skills/. Each skill contains a SKILL.md file, reference documentation, and executable scripts.

SwiftUI Code Generation and Patterns

The swiftui-ui-patterns skill provides reference-driven scaffolding for common iOS interface architectures. Located at plugins/build-ios-apps/skills/swiftui-ui-patterns/SKILL.md, this skill documents patterns for NavigationStack, TabView, Sheets, and state-ownership rules.

The assistant consults references like app-wiring.md to generate production-ready view hierarchies. For complex view hierarchies, the swiftui-view-refactor skill guides decomposition of large views into smaller, stable subviews to improve SwiftUI rendering performance.

Debugging and Simulator Integration

The ios-debugger-agent skill enables direct debugging on the Xcode simulator through Codex-in-app actions. Complementing this, the ios-simulator-browser skill mirrors the simulator display within the Codex browser interface and supports hot-reloading of SwiftUI previews during iterative development.

Performance Profiling

Two specialized skills handle runtime analysis:

• ios-ettrace-performance: Captures ETTrace simulator performance profiles using xcodebuild with the -profile-ettrace flag
• ios-memgraph-leaks: Records memgraph data and compares allocation snapshots to identify memory retention issues

The ETTrace skill includes collect_ios_dsyms.sh for symbol collection, while the memgraph skill provides summarize_memgraph_leaks.py to parse outputs and highlight surviving allocations.

App Intents and System Integration

The ios-app-intents skill facilitates creation of App Intents, Shortcuts, and Siri integration. Located at plugins/build-ios-apps/skills/ios-app-intents/SKILL.md, this skill references first-pass-checklist.md and example-patterns.md to generate intent definitions that expose app functionality to system services like Spotlight and Shortcuts.

Setting Up the Plugin Environment

To enable iOS development capabilities, ensure the plugin configuration files are properly structured in your workspace.

The manifest at .codex-plugin/plugin.json declares the plugin version and skill locations:

{
  "id": "build-ios-apps",
  "name": "Build iOS Apps",
  "skills": [
    "swiftui-ui-patterns",
    "ios-debugger-agent",
    "ios-ettrace-performance"
  ]
}

The MCP configuration in .mcp.json establishes the connection to Xcode-Build-MCP, allowing Codex to execute build commands, launch simulators, and capture debug output without manual script management.

Practical Implementation Examples

The following examples demonstrate how to leverage specific skills within the plugin workflow.

Scaffold a TabView-Based SwiftUI App

Using the swiftui-ui-patterns skill references, generate a scaffolded application with tab-based navigation:

import SwiftUI

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            // Entry point – TabView with NavigationStack per tab
            AppTab()
        }
    }
}

// Reference: plugins/build-ios-apps/skills/swiftui-ui-patterns/references/app-wiring.md
struct AppTab: View {
    var body: some View {
        TabView {
            NavigationStack {
                HomeView()
            }
            .tabItem { Label("Home", systemImage: "house") }

            NavigationStack {
                SettingsView()
            }
            .tabItem { Label("Settings", systemImage: "gear") }
        }
    }
}

Implement a Siri Shortcut with App Intents

Create an App Intent that allows users to open specific app views via Shortcuts:

import AppIntents

struct OpenFavoritesIntent: AppIntent {
    static var title: LocalizedStringResource = "Open Favorites"

    @MainActor
    func perform() async throws -> some IntentResult {
        // Navigate to Favorites screen in the running app
        try await MyAppRouter.shared.navigate(to: .favorites)
        return .result()
    }
}

Capture Performance Profiles with ETTrace

Execute performance profiling through the ios-ettrace-performance skill:

# Codex-in-app command run via the ios-ettrace-performance skill

xcodebuild \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 15,OS=17.2' \
  -profile-ettrace \
  -derivedDataPath /tmp/MyAppDerivedData

The skill's collect_ios_dsyms.sh script wraps symbol collection, producing JSON output viewable in the built-in trace viewer.

Detect Memory Leaks with Memgraph

Utilize the ios-memgraph-leaks skill to capture and compare memory snapshots:

# Run the memgraph-capture script from the ios-memgraph-leaks skill

./scripts/capture_sim_memgraph.sh MyApp iPhone-15

# Compare with previous baseline to identify new leaks

python summarize_memgraph_leaks.py --prev baseline.json --curr new.json

The Python script parses memgraph output and highlights allocations surviving beyond expected lifecycles, helping identify retain cycles and memory pressure issues.

Summary

• The Build iOS Apps plugin in openai/plugins provides nine specialized skills covering the complete development lifecycle from code generation to performance analysis.
• Configuration files .codex-plugin/plugin.json and .mcp.json enable Codex to interface directly with Xcode and the iOS simulator through MCP servers.
• SwiftUI patterns are generated from reference documentation, ensuring adherence to best practices for navigation hierarchies and state management.
• Performance tooling integrates ETTrace profiling and memgraph leak detection directly into the Codex workflow without manual script execution.
• App Intents can be scaffolded to enable Siri integration and Shortcuts support using the dedicated skill documentation.

Frequently Asked Questions

What is the Model Context Protocol (MCP) in the context of OpenAI iOS plugins?

The MCP (Model Context Protocol) is the configuration layer defined in .mcp.json that enables the Codex assistant to execute external tools and commands. For iOS development, it specifically wires the Xcode-Build-MCP server, allowing the assistant to build projects, launch simulators, capture debug logs, and run performance profiling scripts as part of the conversation workflow.

How does the swiftui-ui-patterns skill handle complex view hierarchies?

The swiftui-ui-patterns skill references architectural guidelines in files like app-wiring.md to enforce proper state ownership and view composition. For large view files, the companion swiftui-view-refactor skill provides step-by-step guidance to decompose monolithic views into smaller, reusable subviews that maintain stable identities—critical for SwiftUI's diffing engine and runtime performance.

Can OpenAI plugins debug an app running on a physical iOS device?

Based on the current source code in openai/plugins, the debugging capabilities focus specifically on the Xcode simulator through the ios-debugger-agent and ios-simulator-browser skills. The MCP configuration and skill scripts reference simulator destinations (e.g., platform=iOS Simulator,name=iPhone 15) and ETTrace profiling for simulated environments. Physical device support would require additional provisioning profiles and certificates not currently referenced in the skill documentation.

Where are the skill reference files located in the repository?

Each skill maintains its documentation and examples within structured subdirectories under plugins/build-ios-apps/skills/. For example, SwiftUI patterns reside in plugins/build-ios-apps/skills/swiftui-ui-patterns/SKILL.md and its references/ subdirectory, while App Intent examples are found in plugins/build-ios-apps/skills/ios-app-intents/SKILL.md alongside first-pass-checklist.md and example-patterns.md. The root README.md at plugins/build-ios-apps/README.md provides an index of all available skills and their purposes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}