Engineering Native iOS Applications for iPhone Duo via Agentic Workflows with Claude Opus 5.5

The release of new hardware, such as the recently announced Apple iPhone Duo, traditionally presents a significant barrier to entry for developers due to the need for specialized testing environments and device-specific UI/UX considerations. However, the emergence of high-reasoning agentic models—specifically Anthropic's Claude Opus 5.5—combined with advanced CLI-based coding agents like Claude Code, has fundamentally shifted the paradigm from manual implementation to agentic orchestration. This post explores a technical deep dive into building "Native Board," a dual-pane productivity application designed specifically for the iPhone Duo architecture, using an entirely automated development workflow.

The Technical Toolchain: Environment Configuration

Developing for unreleased or bleeding-edge hardware requires a precise software stack. To simulate the unique form factor of the iPhone Duo, the environment must be configured with specific versions of Apple's developer tools.

Hardware and Core Software

The development was conducted on an M4 MacBook Pro, leveraging the high-performance neural engine for local processing. The core software components include:

• Claude Code: An agentic interface used to execute complex, multi-step coding tasks directly within a local terminal environment.
• Xcode 27.1 Beta: This specific version is critical as it contains the Device Hub updates necessary to recognize and simulate the iPhone Duo hardware profile. Without this beta version, the simulator cannot render the dual-screen orientation or the unique aspect ratios of the Duo.
• Swift: The native programming language for iOS, utilized here to ensure high performance and deep integration with Apple's system frameworks.

External API Integrations

To move beyond a static prototype, the application requires real-time data retrieval and image processing capabilities. Two key APIs were integrated into the agentic workflow:

1. SERP API: Utilized for programmatic Google Search execution to retrieve high-resolution imagery based on user queries.
2. remove.bg API: A specialized computer vision service used to programmatically strip backgrounds from retrieved images, facilitating the "sticker" effect essential to the app's core loop.

Phase 1: Establishing the Baseline (The Hello World Verification)

Before attempting complex feature implementation, it is imperative to validate the connection between the Claude Code agent and the Xcode simulator. The workflow began with a foundational prompt within the Claude Code interface (Command N to initialize).

The initial objective was simple: generate a basic Swift-based "Hello World" application and verify that the agent could successfully trigger a build process that targets the iPhone Duo simulator via Xcode. This step confirms that the agent has the necessary permissions to interact with the local file system, execute xcodebuild commands (or equivalent), and interface with the iOS Simulator's device hub.

Phase 2: Single-Prompt Prototyping and Logic Implementation

The most significant technical milestone was the "one-shot" generation of the core application logic. Using Claude Opus 5.5, a single, highly descriptive prompt was used to define the app's dual-pane architecture. The requirement was an interface inspired by Excalibur: a canvas on the left and a sticker generator on the right.

Architectural Requirements for the Agent

The prompt instructed the model to:

• Implement Dual-Pane UI: Design a horizontal layout optimized for the iPhone Duo’s expanded screen real estate.
• Integrate Search Logic: Use the SERP API to fetch images based on user input.
• Automate Image Processing: Implement a pipeline where fetched images are passed through the remove.bg API, followed by an algorithmic application of a white border (stroke) to create a "sticker" aesthetic.
• Local Persistence: Initially implement a local database for data storage to ensure low-latency testing during the prototype phase.

The agent successfully navigated the complexities of Swift UI implementation and asynchronous API calls. Despite the computational intensity—the process took approximately 37 minutes to complete the full build and logic integration—the resulting binary was functional, capable of searching, processing, and rendering interactive elements on the Duo simulator.

Phase 3: Scaling with Backend-as-a-Service (Convex)

A local database is insufficient for any production-grade application requiring collaboration or cross-device synchronization. To transition from a prototype to a scalable product, we integrated Convex.

The Role of Convex in Agentic Development

Convex serves as a real-time Backend-as-a-Service (BaaS). For an agentic workflow, the integration of the official Convex plugin for Claude Code is transformative. This allows the LLM to:

• Provision Infrastructure: Automatically set up database schemas, backend functions, and file storage.
• Implement Real-Time Sync: Ensure that any change in the database (e.g., adding a new sticker) is reflected instantly across all connected clients without manual polling or complex WebSocket management.
• Enable State Sharing: Generate convex.site links, allowing users to share their "boards" via a URL. This enables a view-only mode for external collaborators while maintaining the integrity of the primary user's data.

By utilizing the Convex plugin, the agent was able to refactor the existing local storage logic into a robust, cloud-based architecture, enabling real-time updates and shareable application states with minimal manual intervention.

Phase 4: Iterative Refinement and UX Optimization

The final stage of the development lifecycle involved iterative prompting to refine the User Experience (UX). The focus shifted from functional correctness to aesthetic and ergonomic optimization. Key technical refinements included:

• Frontend Optimization: Redesigning the landing page to reduce "UI clutter" by minimizing button density and optimizing typography.
• Advanced UI Animations: Implementing programmatic animations that trigger when a user selects an image, visually transitioning the raw search result into a processed sticker format.
• Search Filtering Logic: Enhancing the search bar functionality to include both global searches (via SERP API) and local filtering of existing stickers stored in the Convex database. This required the agent to implement efficient querying logic that scans metadata (the original search term) associated with each sticker object.

Conclusion: The Future of Software Engineering

The development of "Native Board" demonstrates that the bottleneck in software engineering is shifting from syntax implementation to architectural orchestration. By leveraging Claude Opus 5.5's high-reasoning capabilities and the specialized toolsets of Claude Code and Convex, we can move from concept to a fully functional, cloud-synced, multi-pane iOS application in a fraction of the time required by traditional methods. The ability to automate complex tasks—such as API integration, background removal logic, and real-time database schema management—marks the beginning of an era where the developer's primary role is that of a system architect.