Tuist's AI whitepaper

AI is reshaping software development at an unprecedented pace, breaking through limitations that once seemed insurmountable. For Apple developers, this transformation presents unique opportunities and challenges within a platform known for its sophisticated but often opaque tooling.

At Tuist, we've been deeply immersed in exploring how AI can transform the Apple development experience. Through continuous experimentation and community collaboration, we're building bridges between cutting-edge AI capabilities and the realities of Swift and Xcode development.

Inspired by Penpot's thoughtful AI whitepaper, this document shares our vision for AI's role in Apple development. We're taking a pragmatic, incremental approach that enhances rather than replaces existing workflows, working with Apple's tools to unlock new possibilities while respecting the platform's unique constraints and opportunities.

Building the foundation for agentic coding

Since Tuist's inception, we've tackled the most frustrating aspects of Apple development—from decoding Xcode's proprietary project formats to revolutionizing build times through intelligent binary caching. These improvements aren't just quality-of-life enhancements; they're essential infrastructure for the AI-powered future of development.

Here's the critical insight: the same pain points that frustrate human developers completely break agentic coding experiences. When an AI agent modifies your SwiftUI view, it needs immediate feedback—not a 5-minute incremental build that might fail mysteriously. When it refactors your networking layer, it needs to verify the changes instantly, not wait for a full app rebuild and simulator launch.

Agents need fast feedback from multiple sources: the build system, running applications, live previews, and more. Some information can be collected because it exists in the system and either the model has learned about it or accesses it through Model Context Protocols (MCPs). However, agents often lack access to crucial information, such as SwiftUI preview trees resolved at runtime or how the build system processes graphs to generate artifacts.

Some improvements remain outside our direct control, such as enhancing framework documentation, minimizing major Swift changes, or Apple decoupling Xcode's layers and providing programmatic APIs for extension. Whether these changes occur likely depends on Apple's willingness to trust their developer community beyond just app creation to include tool enhancement.

The community is actively bridging the gap between agents and official tools. This includes MCPs that expose CRUD APIs for Xcode projects and solutions that approximate hot-reloading workflows by managing xcodebuild and simulator tools. Until underlying tools provide better APIs and documentation, these translations remain essential.

This brings us to our role. As mentioned earlier, shortening feedback loops is crucial, and we believe this should be our primary contribution. Today, this means binary caching based on project generation, but in the future, when caching is built into the build system, we're working toward creating the fastest, lowest-latency cache solution that agents can access regardless of their location.

Imagine an edge-accelerated Xcode build cache that makes compilation virtually instantaneous, regardless of project size or location. We're building the infrastructure that enables both agents and developers to iterate at the speed of thought. Every build generates rich diagnostic data streamed to ClickHouse, providing immediate insights when things go wrong—because agents need to understand failures just as much as successes.

Autonomous QA: Testing at the speed of development

The traditional testing pyramid is being turned upside down. While unit tests remain valuable, the real game-changer is automated acceptance testing—the kind that actually validates user experiences but has historically been too expensive to maintain.

Consider the current reality: a developer submits a PR, waits for CI, gets feedback hours later, context switches are everywhere. Now imagine this: an AI agent reviews your code, spins up a preview, tests it like a real user would, and provides comprehensive feedback—all within minutes of pushing your changes.

Acceptance tests are expensive to develop because they require learning imperative interfaces for UI interaction through accessibility APIs. Moreover, the contract and use case being tested often remain implicit, making tests fragile and difficult to fix when they break. While Xcode 26 reduces the cost of writing these tests, it addresses only part of the challenge.

An alternative is QA testing, but this approach is equally or more expensive. Human testers are costly, and the process doesn't scale effectively. As variability increases, scenarios multiply, and QA teams often end up testing less critical scenarios because they lack business context to prioritize effectively. When issues arise, the diagnostic information they provide is limited—typically written reports and screenshots without logs, network requests, or database and keychain state information. This leads to significant developer time spent on QA interactions.

Consequently, many companies rely solely on unit tests and solid architecture to prevent certain issues, but this approach cannot catch all scenarios. While no solution is perfect, we believe you can approximate comprehensive testing with minimal cost.

We're making this a reality with Tuist QA. Our AI agents don't just run test scripts—they interact with your app like actual users. They understand context from your PR description, explore edge cases based on code changes, and provide detailed reports with screenshots, logs, and actionable insights.

Here's how it works: mention @tuist-qa in your PR, and within minutes, an agent spins up a macOS environment, installs your app, and methodically tests the changes. It reads your QA.md for context, understands your app's architecture, and focuses testing on what matters most.

All the necessary components for agentic QA are already in place: Tuist supports previews for app bundle uploads with commit and branch tracking, and it integrates with GitHub for event-driven actions. Additionally, integration with Namespace is being built for spinning up macOS environments where agents can operate. Early results are promising.

You mention us in a PR, and we respond shortly after with a summary and link to a detailed testing report that includes logs, screenshots, and all necessary diagnostic information. We gather context from PRs and other sources, such as QA.md files.

Instead of developing and maintaining expensive acceptance test suites, you can simply tag us to test work, and we handle the rest.

Instant previews: Share work in seconds, not hours

In an AI-accelerated development cycle, the ability to instantly share and test changes becomes critical. Traditional preview distribution is broken—it takes hours to get a testable build to stakeholders, and by then, the context is lost.

The fundamental problem? Apple's code signing. Current solutions force you to pre-sign apps for specific devices, meaning every new tester requires a pipeline re-run. Enterprise certificates help but come with their own limitations and costs.

We're solving this with on-demand signing. Instead of signing at build time, we sign at install time—specifically for each device. This means:

• Push code, get a preview link immediately
• Anyone in your organization can install with one tap
• Automatic certificate management
• Feedback flows directly back to your PR or Slack

The future we're building: An agent completes a feature, generates a preview, and your entire team is testing it within seconds. Product managers provide feedback that agents immediately incorporate. The development cycle compresses from days to hours.

We'll also build an SDK that collects feedback and forwards it to places where agents can access context, whether Slack channels or GitHub PRs. If we develop an alternative experience for idea ignition, you'll have a "share" button that completes with "here's your link, share it with the world"—because that's how we believe developer experience should work.

Unlocking Apple's black box: Data accessibility for AI

Apple's development ecosystem is notoriously opaque. Build logs are binary, project formats are undocumented, and runtime behavior is largely invisible. This opacity becomes a critical bottleneck when AI agents need to understand what's happening in your codebase.

We're systematically breaking down these barriers:

• Build insights: We parse .xcactivitylog files to extract compilation times, bottlenecks, and failure patterns
• Bundle analysis: Rosalind transforms binary artifacts into queryable schemas
• Test intelligence: Real-time analysis of test execution, flakiness patterns, and coverage gaps
• Runtime telemetry: Capturing and structuring app behavior data for agent consumption

If you've used tools like Claude Code, you've likely noticed it knows how to interface with GitHub CLI to view PR comments and address them. GitHub provides data and makes it accessible through CLI for agent consumption. We're adopting a similar approach, where agents can plan work by examining flaky tests in test suites or optimize project build parallelization by analyzing project graphs and build result data.

As mentioned earlier, since these formats and internal layers are designed to feed upper internal layers rather than external tools that could enhance development experience, Apple may be hesitant to expose them. Opening these systems might enable ecosystem development around alternative coding experiences, as we're seeing with increased Cursor adoption for iOS development. While we believe such openness would be hugely beneficial, Apple's approach continues to evolve in interesting ways that suggest growing openness to developer tool innovation.

From idea to app: Exploring rapid materialization

Every great app starts as a spark of inspiration—a "what if" moment that demands exploration. But the path from idea to working prototype is often where that spark dies, buried under setup complexity, build configurations, and distribution friction.

The industry is attacking this problem from multiple angles. VibeTunnel validated that developers want to continue development remotely or on the go. Meanwhile, tools like Lovable and V0 are presenting hosted, conversational no-code-like solutions that enable rapid prototyping through natural language. But Apple development presents unique challenges: native capabilities are essential, but the platform's controlled distribution creates inherent friction.

We're exploring this frontier with Ignite, our experiment in zero-friction prototyping:

• Instant setup: No Xcode projects, no configurations—just start coding
• Live preview: Changes reflect immediately in your browser
• Develop anywhere: Continue building from any device, anytime, without local setup
• Native bridge: Access platform capabilities without leaving the rapid iteration loop

This isn't about replacing native development—it's about creating the fastest possible path from idea to validation. Once you know something works, our infrastructure helps you graduate to a full native implementation with proper testing, distribution, and all the platform capabilities you need.

Importantly, we're holding to see how this space evolves. The rapid pace of change means what seems promising today might be obsolete tomorrow. We recognize that full agentic coding solutions are massive undertakings better suited to generic players in the space. Our approach is more measured—we're interested in how our specific strengths in caching, build optimization, and the Apple ecosystem can contribute to lowering the barriers to idea exploration.

Some of this work is already happening through our existing infrastructure. Our binary caching reduces build times, our preview system enables rapid sharing, and our data accessibility efforts provide the context agents need. Each improvement reduces the incremental cost of exploration, which increases our appetite to continue investing in this direction—but always with a focus on what uniquely benefits Apple developers.

The journey ahead

What dominates discussions today may be obsolete tomorrow. The pace of change in this space is extraordinary, which is why we approach these ideas with an exploratory mindset, discussing and refining them weekly as a team. We remain open-minded in some areas while focusing our energy where we see solid opportunities, like Tuist QA.

Moreover, some problems like coding can be well-addressed by generic solutions like Claude Code that have learned Swift and can interface with external systems through MCPs. However, other challenges benefit from vertical solutions built upon existing platforms, specifically designed for app development and requiring ecosystem knowledge and expertise—which we've developed over years of building tools for Xcode and Swift.

We'll focus on areas where we can bring exceptional value within our vertical—value that organizations can perceive instantly and that wouldn't make economic sense for generic solutions to pursue. Our strong understanding of Apple's ecosystem, combined with years of solving developer pain points, positions us to deliver specialized solutions that generic tools simply can't justify building.

We built Tuist to help teams and developers address existing challenges, but also to explore ideas that make development more enjoyable and accessible to everyone. We want more people building more apps for the Apple ecosystem.

Get involved: If you're intrigued by any of these ideas or would like to try the experiences we're building, we'd love to hear from you. Reach out to us at [email protected] or join the conversation in our community. The future of Apple development is being written now, and we believe it's better when we write it together.