Stellar

Alex: AI for Xcode

<-Back to Blog

Cursor vs Alex (vs Windsurf)

Daniel Edrisian · April 8, 2025

Cursor vs. Alex vs. Windsurf for iOS Development

I get this question asked a lot: "For iOS Development, should I use Cursor or Alex?" And now that there's windsurf also in the mix, it's an even more relevant topic to discuss.

Firstly, Cursor and Winsurf fall in the category of "VSCode Forks". They are essentially VSCode, but with some sidebars and added features like AI Chat.

Alex, on the other hand, is a separate sidebar app that integrates directly with Xcode. It's not an IDE itself.

The Main Difference: Xcode vs VSCode

With Cursor & Windsurf, you are forced to use VSCode. VSCode is a lightweight IDE, which has its pros (I like it a lot for server/fullstack development), but without extensive improvements and extensions, it is difficult to build iOS apps in it.

Some areas they suffer in:

XcodeProj files

VSCode cannot natively parse XcodeProj files. This makes it a pain to set your build settings, capabilities, signing, phases, etc. There's a solution for this called Tuist which helps generate XcodeProj files. Though if you're new to iOS/Mac development, this is on the harder end of getting things set up.

Xcode, on the other hand, natively handles this. And it manages your signing and developer accounts.

LLDB (Debugger)

Debugging is an essential part of coding apps. You need to set breakpoints to figure out what's going wrong. Xcode easily lets you set breakpoints and interact with the LLDB, which lets you print values and run expressions while your app is running.

VSCode doesn't support this out of the box. For that, you will have to set up the SweetPad extension. The set up of this extension is a bit involved, but with enough work you can get the LLDB working.

Stack Traces (and handling Crashes)

As Swift is a compiled language, you may sometimes run into a crash that completely siezes your app. Xcode automatically shows which line this crash happened at, and gives you a helpful stack trace that you can click through, to see what led to the exception.

VSCode, even with SweetPad, cannot help you here. You can see the crash log when SweetPad executes xcodebuild (the command for running your app), but it's not interactive the way Xcode is. This makes debugging crashes exceptionally difficult in VSCode (pun 100% intended.)

Build Times

Given SweetPad uses xcodebuild to build and run your apps, it's often a lot slower than running build through Xcode. Why? Because Xcode is closed source, and their build system is prioprietary. There's really no good solution for this in VSCode land.

Macros

With newer Swift versions and iOS SDKs, Apple has been leaning into Macros! You often interact with them when using the @Observable macro when making your state managers.

These macros generate code that is invisible to you, the developer, until the app has been compiled.

Xcode conveniently shows you these macro code-generations underneath the original swift code you've written. This is especially helpful when there's a conflict or error in the macro, and 100% necessary when there's a crash that happens inside the generated code.

VSCode, and the Swift extensions, do not cover these. You'll have to open Xcode for it.

Previews

Xcode has previews for SwiftUI. There are some projects out there like InjectionIII which let you have hot-reloading in Swift, but it's TBD if these libraries are as simple to setup and use than previews. If you have experience with them, let me know!

Previews are nice, but sometimes painful when things go wrong. So I'm putting it way down here in terms of value because I just usually don't use them for production grade apps.

Alex vs. Cursor

Those are some of the main differences in the IDE realm which point to using Xcode for iOS/Apple dev. There are other things too, like Crash Logs, UI Testing, CPU/memory/resource observation, in-line Apple Documentation, etc. that I won't go into. But it's all to say that Xcode is made for Swift and iOS dev. Everything is just ready for you.

Now, barring all these differences, how does Alex compare to Cursor in generated code quality and user-experience?

Agentic Chat

Both Alex, Cursor, and Windsurf have agentic chat. I consider them all to be pretty similar in capability, though Cursor and Windsurf currently have better semantic search tools.

Generated Code quality

Cursor and Windsurf are used by all kinds of devs, so their system prompts are pretty ambiguous (and tailored more to the JavaScript/Python ecosystem). Alex's system prompt is tailored to Swift exclusively, and we've given it some best practices to generate more up-to-date code with fewer warnings and deprecations. This means less time waste!

Code Maps

Both Alex, Cursor, and Windsurf can use multiple files in your context. But Alex has a unique edge here: We parse and understand your Swift codebase!

Imagine you have a file called EmailView.swift:

import SwiftUI
 
struct EmailView: View {
    @Environment(EmailManager.self) var emailManager
 
    var body: some View {
        ScrollView {
            LazyVStack {
                ForEach(emailManager.emails) {
                    VStack {
                        Text("\($0.subject)")
                        Text("\($0.sender)")
                    }
                }
            }
        }
    }
}

EmailView is using an EmailManager which is an observable manager that contains all my emails.

This EmailView.swift file doesn't include any implementations of EmailManager, or even what type "Email" is, or its properties.

If I were to give this file to Cursor or Windsurf and said "Please also include a preview of the email underneath the subject" it wouldn't know what kind of properties email has! It would have to spend some time reading the file EmailManager.swift to understand it.

At Alex, we've implemented code maps that understand this behavior. We automatically pull the dependencies of the files you're chatting about, so that our agent knows their interface. Basically looks like:

// Interface for EmailManager.swift:
struct Email {
    let subject: String
    let sender: String
    let preview: String
    let content: String
}
 
 
    init()
    func fetchEmails()
    ...
}
 
 
// EmailView.swift
import SwiftUI
 
struct EmailView: View {
    @Environment(EmailManager.self) var emailManager
 
    var body: some View {
        ScrollView {
            LazyVStack {
                ForEach(emailManager.emails) {
                    VStack {
                        Text("\($0.subject)")
                        Text("\($0.sender)")
                    }
                }
            }
        }
    }
}

Now alex will know that it can add $0.preview to the SwiftUI view, because it can see the dependency interfaces!

Cursor and Windsurf don't have this. We do, because Swift is our entire focus.

Fixing Swift 6 Issues

Sending the announcement of Swift 6, most of the concurrency issues that were just warnings in Swift 5+ became Errors.

Unfortunately, many LLMs don't have this knowledge baked into their training, as they use stack overflow/forum contents from years past.

Alex Sidebar automatically detects when you have a Swift 6/concurrency related issue, and fixes it for you with one click! We inject up-to-date best practices, and have the model think before answering.

Cursor and Windsurf have autofixing issues, just like we do, but they're very simplistic and don't have this level of knowledge. They could spend many iterations trying to fix your project, and end up messing something up in the process. Concurrency is hard!

Thinking Mode

Alex also has a "Thinking Mode" which is far better than Cursor/Windsurf's. We use DeepSeek R1's reasoning traces and inject them into Claude 3.5 Sonnet (or any other model you use). This leads to far better code output, much better than even Claude 3.7 Sonnet Thinking for Swift.

File Assistant ⚡

Alex has a ludicrously fast feature called "File Assistant", which let's you do your refactors, and file-level operations much much faster than using chat, autocomplete, or even doing it yourself. This is something that even senior engineers who are faster than AI can benefit from.

Voice Mode & Project Memories

Alex lets you natively talk to it. Just hit Cmd+shift+V, speak, and hit send. It uses Whisper to generate better much transcriptions than Apple's voice input.

We also have Project Memories, and so does Windsurf, but not Cursor. Windsurf's project memories is better than ours, currently.

Working with Groups (for legacy Xcode Projects)

If you're reading this part, it means you know the pain.

We can modify the Xcode target directly, and add/remove files including their build file references. This means you don't have to manually click "Add File" every time you make the file in Cursor/Windsurf.

Apple Docs

Alex can individually add apple docs to context, or use RAG to pull relevant Apple Docs. For example, you can simply do @Combine or @AVFoundation and have Alex use them as context.

TBH this wasn't as valuable as I first thought it would be when I created it, which is why it's down in the list. But still not bad when you're desparately out of ideas.

The things we all have

  1. Multi-file Applying
  2. Checkpoints
  3. Codebase Search
  4. Image Chat (Except that we have a better integration for this, including screenshotting + annotating!)
  5. Selecting lines from the editor
  6. Cmd+K (inline completion)
  7. Web Search
  8. URL Importing
  9. Git Commit generation
  10. Model selector. Select from Claude 3.5, Claude 3.7, GPT 4o, o1, o3-mini, DeepSeek R1, DeepSeek V3, and Gemini 2.5 Pro.
  11. Adding custom models and using your own API keys

The things Alex doesn't have

  1. Docs (like using Stripe Docs)
  2. MCP (though we have a native integration for Github Issues and Linear)
  3. "Next Edit" aka. tab tab tab. We have a basic autocomplete which is already far better than our competitors, like Copilot or Xcode's.
  4. Auto-Accepting/Running terminal commands agentically. Windsurf/Cursor can do this currently, I just haven't gotten to enabling this yet.

Customer Support

We also have really good customer support! It's usually instant, if you join our Discord

Pricing

Alex has a much better Free plan than either Cursor or Windsurf's. Check out our comparison here.

Conclusion

In conclusion, Alex Sidebar is made specifically for iOS and MacOS development. Here's what some of our users have said:

Whether you're a pro-coder or a vibe-coder, we help you build apps faster!

Try out Alex with our free plan, or our one-week trial of Pro / Premium: Download