CursorAI and Upcoming Swift Assist — SitePoint

The landscape of iOS engineering has seen a remarkable transformation since its inception, evolving from days of Interface Builder to AI-enhanced development workflows. Programmers from all backgrounds are reporting an increase in productivity through AI assistance, we are seeing a fundamental shift in how iOS applications are conceptualized and built.

However, this rise in AI assisted development brings both opportunities and challenges that every iOS developer needs to understand.

Key Takeaways

• AI-assisted development tools are reshaping iOS development workflows, with research showing up to 50% improvement in documentation speed and 35-45% faster code generation, though they remain limited by the “70% problem” when handling complex architectural tasks.

• CursorAI stands out through its Composer and Chat features, enabling simultaneous multi-file operations and UI reverse engineering while maintaining project-wide context and architectural patterns like MVVM.

• While AI tools excel at automating routine tasks and generating boilerplate code, successful iOS development still requires human expertise for crucial aspects like debugging, performance optimization, and App Store compliance.

The Evolution of iOS Development

iOS engineering has come a long way, just like the arch of software engineering in general. Back in the day, iOS engineers used Interface Builder and XIB files, which were like XML files for creating static views.

But things changed in 2014 when Apple introduced Swift, its new programming language. At first, UI frameworks like UIKit were updated to work with Swift, but they still had their roots in Objective-C. Then, in June 2019, SwiftUI came along. This was a game-changer.

SwiftUI is like a declarative framework that lets you build user interfaces across all Apple platforms. It’s a whole new way of thinking about iOS development, moving from the old way of doing things to a more modern, component-based approach.

This evolution wasn’t just about the code. It changed how developers thought about iOS apps. Instead of having to manually layout everything, they could now create adaptive interfaces that change based on the device and user preferences. And with the componentized architecture, they could reuse code and make maintenance easier.

Plus, type inference and Automatic Reference Counting made things simpler and more efficient. It also brought about easy implementation of functional reactive programming to iOS development. Each step forward brought iOS development closer to the modern, efficient process we know today.

The AI Revolution in Development

In 2024, Apple unveiled Swift Assist, their first AI code generation tool. This 70B+ parameter model, specifically trained on Swift code, SDKs, and documentation, marked Apple’s official entry into AI-assisted development. Swift Assist is currently still being developed and is yet to be released to the public.

McKinsey’s research shows that AI is good at some tasks, but not all. It can speed up code documentation by up to 50% and make code generation 35-45% faster. But it’s not great at very complex tasks. Engineering leader Addy Osmani calls this the “70% problem” because AI tools are great at relatively simple tasks, but they need humans to intervene in complex tasks.

AI coding assistants can be highly beneficial in automating the creation of boilerplate code and implementing standard features. They also provide assistance with fundamental optimization and security considerations.

However, their capabilities are limited when it comes to complex tasks such as designing the system architecture, optimizing performance, or comprehending the interplay between different system components. Additionally, they cannot handle exceptional scenarios or discern the overall integration of the system.

The current ecosystem of AI development tools offers various approaches to enhancing the development process. Apple’s Swift Assist represents the platform owner’s vision, with deep integration into the development environment and specific optimization for Swift and Apple frameworks.

GitHub Copilot offers broad language support and deep integration with version control workflows. ChatGPT and Claude offer general LLMs that allow one to copy and paste code into their portals and prompt to further enhance their code and make modifications. 

Among these tools, CursorAI has emerged as a particularly compelling option for iOS engineers. It combines familiarity with Visual Studio Code with features that are uniquely suited for iOS engineers. CursorAI also easily addresses one of the biggest hurdles of coding with ChatGPT and Claude – manually copying and pasting code into a web browser.

CursorAI’s ability to comprehend project context, adapt to existing codebases, and support multiple AI models makes it well-suited for professional iOS development workflows.

Introduction to iOS Development With CursorAI

Going forward with this article, we will delve into how CursorAI can bolster iOS development. Understanding how to effectively integrate CursorAI into your iOS development workflow requires careful consideration of both tool configuration and development practices.

The following sections demonstrate how to configure CursorAI for optimal performance and explore practical implementations through a sample note-taking application.

To demonstrate CursorAI’s capabilities, we’ll create a simple note-taking application called NoteTaker. After creating a new project in Xcode with the default SwiftUI template, we’ll open it in CursorAI to begin enhancing our development workflow.

This example will showcase how AI assistance can streamline common iOS development tasks while maintaining code quality and architectural best practices.

Understanding AI Roles and Context

One of CursorAI’s most potent capabilities is its ability to comprehend and adapt to distinct development roles and contexts. It is crucial to configure CursorAI to understand your project’s architectural structure and patterns.

This entails establishing AI roles that correspond to your development methodology, such as specifying MVVM architecture preferences or SwiftUI-oriented development patterns. 

There are two methods for defining rules for CursorAI: you can establish general rules for all projects or specific rules for a particular project. For our instance, let us configure rules for all projects. 

To set rules for all projects, go to Cursor > Settings > Cursor Settings. Then under General > Rules for AI, you’ll be able to instruct the IDE with a specific set of rules. For this tutorial, we’ll use the pre-set rules shared by Ray Fernando’s blog post.

When configuring CursorAI for iOS development, we should establish clear guidelines about our development practices. This helps ensure that AI suggestions align with our project’s standards and architectural decisions. For example, we can specify our preference for SwiftUI over UIKit, MVVM architecture, and any specific coding conventions our team follows.

Practical iOS Development Tips With CursorAI

Now that we’re done with the basic setup, let’s explore some practical ways CursorAI can enhance your iOS development workflow. Let’s explore some features like Composer and Chat, and how CursorAI can bolster the productivity of iOS developers in unique ways.

Using Composer to Work With Multiple Files

The Composer feature sets CursorAI apart from traditional AI-based IDEs by providing comprehensive project-wide code generation and refactoring capabilities. Unlike conventional tools that necessitate manual copy-pasting between files, Composer comprehends the entire codebase context, enabling seamless multi-file operations. 

This contextual awareness is particularly valuable for iOS development, where features often span multiple SwiftUI views, view models, and data models. With the Composer feature, one can effortlessly manipulate multiple files and prompt with the assurance that all files in the codebase can be refactored from a centralized location.

One of the ways the Composer feature can be particularly beneficial is when we want to create multiple new files for a specific functionality within our application. For instance, let’s consider the scenario where we want to create a new SwiftUI view and a corresponding ViewModel for that view. Let’s explore the process of implementing this functionality using the Composer feature.

To utilize the Composer feature:

1. Access the Composer interface by pressing CMD+I

2. Provide a detailed prompt describing your desired implementation

3. Be specific about architectural patterns (MVVM, SwiftUI practices)

4. Include any relevant constraints or requirements

5. Press enter to generate the implementation

For example, when creating a new functionality, your prompt might say: “Create a new note entry view using MVVM architecture with SwiftUI, including input validation and local storage functionality.”

After submitting your prompt, CursorAI will:

1. Generate suggested code changes with detailed explanations

2. Provide options for selective implementation:

•  Accept all changes across affected files
•  Choose specific changes to implement
• Request modifications to better match your requirements

3. Preview the impact on your codebase before applying changes

This iterative approach ensures that AI-generated code aligns with your project’s standards while giving you full control over the implementation details. With just one clear and concise prompt we were able to produce a basic and functional feature for our note-taking app that lets us enter and display notes.

With this example, we can see how we were able to work with the entire project to create new files named MainView and MainViewModel and use Composer to handle multiple files simultaneously. 

Working With CursorAI’s Chat and Edit Features

CursorAI provides comprehensive code analysis capabilities and supports targeted refactoring of specific code sections. CursorAI’s chat feature lets you converse with an LLM and understand certain files, attach images to reverse engineer, and debug. CursorAI’s edit feature works well with code completion within a single file.

Refactoring Specific Lines Of Code

The following example demonstrates how to refactor specific sections of code in the MainView file using CursorAI’s edit feature. Let’s say we want our notes that are saved to be displayed in gradient squares displayed in a SwiftUI-based ScrollView.

Select all lines of code within the MainView struct, then press CMD+K, within the dialog box, give clear and concise instructions on how to refactor these lines. We want to display all the notes in a square-shaped list with gradient backgrounds, we also want to ensure that the TextEditor and main title text remain at the top of the screen.

You can also attach documentation or tutorials on specific topics, in our case, a tutorial on CollectionViews in SwiftUI was attached with the prompt. To make the most of this feature, be very specific, concise and define limits.

Once you enter your prompt and accept the code suggestion, CursorAI will implement those changes. If we check the state of our updated UI, we can see that the exact changes we asked for were implemented while ensuring code quality is maintained.

Reverse Engineering UserInterfaces Using CursorAI’s Chat

Similar to coding with ChatGPT and Claude, CursorAI lets you deeply analyze code, debug, and refactor code by prompting in a chat-based interface.

To showcase this feature, let’s work with one of CursorAI’s best functionalities: reverse engineering UIs from image attachments. As an example, let’s try to refactor the button in the MainView.

Let’s enhance our MainView’s default button implementation with a custom design:

1. In MainView.swift, locate and select the button implementation code

2. Press CMD+L to open CursorAI’s chat interface

3. Attach a reference image of your desired button design

4. Provide specific styling requirements (animations, transitions, etc.)

This workflow demonstrates how CursorAI can transform basic SwiftUI components into polished, production-ready UI elements while maintaining SwiftUI best practices and performance considerations.
With the image attached, let’s prompt CursorAI with clear instructions on how our button should look and animate when interacted with while instructing on how to feel inspired by the mock button design.

After CursorAI has suggested changes, review them and accept and apply those changes. If you run the app again we can clearly see how only our button has changed while keeping other aspects of our code in the MainView file intact. 

The integration of AI-based IDEs and AI tools into iOS development workflows presents an exciting frontier. While tools such as CursorAI excel at suggesting solutions through a convenient user interface, they cannot replace methodical debugging practices and architectural decision-making.

The key lies in utilizing AI as a collaborative tool rather than relying on it for automatic fixes. For instance, when debugging complex issues involving state management or memory leaks, AI can assist in identifying patterns and suggesting potential solutions, but developers must still comprehend the underlying problems and validate the proposed fixes within their specific context.

While developers can utilize the features presented by tools like CursorAI to quickly build a rudimentary application, an application that truly scales, withstands edge cases, and is accepted into the Apple App Store needs deep thinking and a comprehensive understanding of technical concepts from developers. 

Conclusion

Integrating AI tools like CursorAI into iOS development workflows revolutionizes application building. However, success lies in understanding how to leverage these tools effectively while maintaining best practices.

The key is finding the right balance: using AI to accelerate development while ensuring good software design principles aren’t compromised. As AI tools evolve, this balance becomes crucial for iOS developers.