Seeking Advice on Switching from Cursor to GitHub Copilot

[yccheok]

Select Topic Area

Question

Copilot Feature Area

General

Body

I'm considering migrating from Cursor to GitHub Copilot due to its lower monthly cost.

I have a couple of questions:

1. How can I achieve functionality equivalent to .cursorrules in Copilot? For example, I want to specify context like:

    You are an expert iOS developer using Swift and SwiftUI. Follow these guidelines:


    # Code Structure

    - Use Swift's latest features and protocol-oriented programming

2. How can I provide a list of official Apple documentation to the development environment so I can receive more accurate and relevant AI suggestions? In cursor, we can achieve so via

https://uxplanet.org/vibe-coding-with-cursor-ai-52f5023bc59a

Thank you.

[SouffleSource]

1. Replicating .cursorrules Functionality

GitHub Copilot supports repository-level instructions via .github/copilot-instructions.md. You can do this at Repo and Org level.

# iOS Development Guidelines  
- Use Swift 5.9 features (async/await, Swift Concurrency)  
- Implement protocol-oriented patterns  
- Apply SwiftUI declarative syntax for UI components  
- Use `@Observable` macros for state management  

2. Documentation Integration

Add Apple documentation via:

Organization knowledge bases: Link Apple’s Swift/SwiftUI repositories in GitHub settings
Dynamic context attachment: Use #attach("apple-docs.md") in code or CopilotContext.file() in sessions

[sheldonhull]

I can't find anything in docs on org level instructions. Assumed that would be either the refined box that's very limited in size (609 characters) or that .github repo in the org could be used. Any insight?

[Akash1134]

Hi @yccheok,

Thanks for considering GitHub Copilot as you look to migrate from Cursor! We'd be happy to address your specific questions about iOS development workflows.

1. Creating the equivalent of Cursor's .cursorrules in GitHub Copilot

Great news - GitHub Copilot has a very similar feature using repository-level custom instructions! Here's how it works:

You'll want to create a .github/copilot-instructions.md file at the root of your repository. This file serves the same purpose as Cursor's .cursorrules, allowing you to specify your iOS development preferences.

For your specific Swift/SwiftUI needs, you might create something like:

# iOS Development Guidelines

You are an expert iOS developer using Swift and SwiftUI. 

## Code Structure
- Use Swift's latest features and protocol-oriented programming
- Apply SwiftUI declarative syntax for UI components
- Use @Observable macros for state management 

## Best Practices
- Follow Apple's official coding guidelines
- Create modular, reusable components
- Implement proper error handling

The VS Code docs confirm that these instructions are automatically included in every Copilot interaction within that repository, similar to how Cursor's rules work. Just make sure to enable the setting github.copilot.chat.codeGeneration.useInstructionFiles in your VS Code settings.

2. Providing Apple documentation for more accurate suggestions

While Copilot doesn't have the exact same approach as Cursor for integrating documentation, we have several effective ways to accomplish this:

When you're working on a specific iOS problem, you can:

1. Add context in Copilot Chat - Simply paste relevant snippets from Apple's documentation directly in your chat prompt. For example: "Here's the Apple documentation for SwiftUI view modifiers: [paste documentation]. Can you help me implement a custom modifier that does X?"

2. Reference key files - In Copilot Chat, use the #file syntax to reference relevant Swift files: "#MySwiftUIView.swift - Help me improve this view with better animations"

3. Create documentation references - For frequently used frameworks, you could create a docs/ folder with markdown summaries of key Apple frameworks and reference them in your instructions file.

I find that many iOS developers create a dedicated "AppleAPIs.md" file with snippets of their most-used APIs, which gives Copilot better context for your codebase.

What's working well for other iOS developers

Many developers who've made this switch particularly appreciate that GitHub Copilot:

• Picks up context from your entire project structure (very helpful with complex iOS app architectures)
• Provides better Swift code completions when working with SwiftUI previews
• Integrates naturally with GitHub repositories for collaborative iOS projects

Would you like me to share some specific examples of iOS-specific settings that other Swift developers are using with GitHub Copilot? I'd be happy to go into more detail about optimizing the experience for your particular iOS development needs!

[yccheok]

Thank you for your response.

I prefer not to pursue the following approaches:

1. Add context in Copilot Chat - This method is cumbersome, as it requires specifying the relevant documentation in every prompt. Moreover, it's unclear which documentation would be most useful to the LLM.
2. Reference key files - Same as 1.
3. Create documentation references - This approach interests me. Could you show me how to set it up?

I've always had the impression that feeding all iOS-related documentation to an LLM could improve the accuracy of its responses. I'm not certain how true that is, but it's what I currently do in Cursor – I upload all relevant iOS documentation.

As a result, when I chat with the LLM, I don’t need to explicitly reference API documentation, as I assume it has already developed specialised knowledge in iOS development based on the documentation I’ve provided.

Thank you.

[eric-burel]

It's indeed difficult to assess in Cursor, this is the kind of things you'd want to test when you first add the documentation, asking a question that is not satisfactory, adding the docs, and starting over. I've asked how to setup a fresh context in Cursor to run experiments but answers were not super satisfactory.
Anyway this is definitely a missing feature in GitHub Copilot. Maybe there is some doc indexing at backend level (like GitHub indexing key repositories to feed Copilot agent), but we can't confirm and it probably will never concern lesser known libraries, which ironically are those who needs AI the most.

[Chanirulk]

If you're doing iOS development with SwiftUI, switching from Cursor to GitHub Copilot has some pros and cons to consider.

Pros of GitHub Copilot (for SwiftUI developers):

Copilot integrates directly into Xcode via the official plugin, so you can stay within your native development environment.

It's great at generating common SwiftUI code patterns — things like @State variables, reusable View components, NavigationStack, and common modifiers (.padding(), .background(), etc.).

It speeds up repetitive tasks like building forms, lists, and UI scaffolding.

Also helpful with parsing JSON into Swift structs and generating basic Combine or async/await code.

Things Cursor might do better:

Cursor is more IDE-like, with an emphasis on code navigation, live previews, and direct context awareness in a more interactive way.

It allows more advanced editing workflows (like custom instructions and structured refactors), which Copilot doesn't currently support as deeply in Xcode.

Cursor might give you more control over how the AI assists you, especially when iterating on larger chunks of code.

Bottom line:
If you value deep integration with Xcode and want fast code completions for SwiftUI, Copilot is a solid choice. But if you're used to Cursor’s advanced editing features or structured AI interactions, the switch may feel like a step back in terms of control.

It really depends on your workflow — Copilot is great for speeding up UI scaffolding and small components, while Cursor might be better if you rely heavily on AI for deeper refactoring or project-wide edits.

[Gecko51]

For the .cursorrules equivalent, the answer above covers it well: create .github/copilot-instructions.md at the repo root and Copilot will automatically include it in every chat interaction. You can be as detailed as you want there.

For the documentation indexing question (which is the harder one): Copilot doesn't have a native "upload docs" feature like Cursor. Here's the closest you can get today:

Create a docs reference file in your repo. Make something like docs/swift-context.md with the APIs you use most, code patterns, SwiftUI version-specific notes, etc. Then either reference it manually with #file:docs/swift-context.md or add a line to your copilot-instructions.md instructing Copilot to treat it as a context file:

# iOS Development
When generating Swift/SwiftUI code, treat the contents of `docs/swift-context.md` as your primary API reference.

Use #codebase context. In agent mode, Copilot will crawl your workspace. If you have a well-structured iOS project with real SwiftUI code, it builds its own understanding of your patterns without you needing to reference docs manually.

The honest comparison: Cursor's doc indexing (where you literally paste a URL and it gets indexed) doesn't have a direct equivalent in Copilot yet. You're working around it rather than replacing it. For standard Apple frameworks (SwiftUI, UIKit, Combine, async/await) the base model is well-trained anyway, so you usually don't need to feed it docs unless you're using very new or niche APIs. That's where the manual docs/ folder approach helps most.