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

> Learn to build iOS apps with OpenAI plugins. Generate SwiftUI code debug with Xcode and integrate MCP using Codex skills. Your complete guide to App Intents and performance profiling.

- Repository: [OpenAI/plugins](https://github.com/openai/plugins)
- Tags: how-to-guide
- Published: 2026-09-10

---

**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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/.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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/collect_ios_dsyms.sh) for symbol collection, while the memgraph skill provides [`summarize_memgraph_leaks.py`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/plugins/build-ios-apps/skills/ios-app-intents/SKILL.md), this skill references [`first-pass-checklist.md`](https://github.com/openai/plugins/blob/main/first-pass-checklist.md) and [`example-patterns.md`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/.codex-plugin/plugin.json) declares the plugin version and skill locations:

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

```

The MCP configuration in [`.mcp.json`](https://github.com/openai/plugins/blob/main/.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:

```swift
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:

```swift
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:

```bash

# 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`](https://github.com/openai/plugins/blob/main/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:

```bash

# 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`](https://github.com/openai/plugins/blob/main/.codex-plugin/plugin.json) and [`.mcp.json`](https://github.com/openai/plugins/blob/main/.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`](https://github.com/openai/plugins/blob/main/.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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/plugins/build-ios-apps/skills/ios-app-intents/SKILL.md) alongside [`first-pass-checklist.md`](https://github.com/openai/plugins/blob/main/first-pass-checklist.md) and [`example-patterns.md`](https://github.com/openai/plugins/blob/main/example-patterns.md). The root [`README.md`](https://github.com/openai/plugins/blob/main/README.md) at [`plugins/build-ios-apps/README.md`](https://github.com/openai/plugins/blob/main/plugins/build-ios-apps/README.md) provides an index of all available skills and their purposes.