Copilot vs Cursor vs Cody vs Supermaven vs Aider

I used GitHub Copilot from early 2022 to mid 2024 and switched to Cursor at the beginning of 2024. I've tested Sourcegraph Cody and Supermaven along the way. Currently, I use Cursor exclusively for all my development work, powered by Claude 3.5 Sonnet (New). I'm also planning to incorporate Aider Chat into my workflow, and keeping an eye on Zed Editor once it supports Windows.

The GitHub Copilot Era

GitHub Copilot revolutionized coding with its AI-powered autocomplete. Despite critics dismissing it as "just a fancy autocomplete," it was exactly this simplicity that made it powerful. The magic wasn't just in saving a few keystrokes - it was in eliminating the constant context-switching between coding and documentation/StackOverflow searches.

Copilot excels at:

• Suggesting exactly what you need at your cursor position
• Understanding code context naturally
• Responding to simple comments like // do xyz with accurate implementations
• Maintaining flow while coding without interruption

When GitHub later added features like chat and other integrations, they felt bolted on. I installed them but found myself gravitating toward dedicated chat services like ChatGPT and Claude for those use cases.

Enter Cursor: The Game-Changer

Cursor emerged as a comprehensive solution that changed how I approach AI-assisted coding. Its killer feature? The Ctrl+K command. This simple shortcut enables powerful code modifications:

1. Select code (often an entire file)
2. Hit Ctrl+K
3. Describe what you want to change
4. Review the changes in an elegant diff view with additions in green and deletions in red
5. Accept or reject with a single click

While Cursor initially included "Copilot++" as their autocomplete solution, I found it disorienting - it would suggest multiple changes across different file locations simultaneously. I stuck with GitHub Copilot inside Cursor (which is possible since Cursor is essentially a VSCode fork).

The Evolution of Autocomplete

The autocomplete landscape has evolved significantly:

• Supermaven emerged as a superior alternative to GitHub Copilot
• Cursor's new "Tab" feature has matured significantly, replacing their earlier Copilot++
• I've now removed both GitHub Copilot and Supermaven, exclusively using Cursor's Tab feature

Other Notable Players

Sourcegraph Cody

Cody offers similar functionality to Cursor but as a VSCode plugin. While feature-complete, it falls short in two key areas:

• Less reliable code modifications compared to Cursor's Ctrl+K
• Limited diff visualization due to VSCode plugin constraints

Zed Editor

Created by the team behind Atom and Tree-sitter, Zed looks promising with its built-in AI capabilities. However, it's currently unavailable for Windows users.

Current Setup and Future Direction

My current setup is streamlined:

• Cursor for everything:
  • Tab feature for autocomplete
  • Ctrl+K for code modifications
  • Chat feature (though I still prefer the Claude web interface for complex discussions)
  • Claude 3.5 Sonnet (New) as my preferred model

Looking Forward: Cursor Composer and Aider

Two tools are particularly interesting for the future:

Cursor Composer shows promise but needs refinement:

• Changes multiple files in one go
• Currently feels somewhat chaotic
• Needs better transparency in its operations

Aider Chat is an exciting CLI alternative:

• Mature and open-source
• Command-line based
• Requires a deeper mental model but offers powerful capabilities
• Perfect for those who prefer terminal-based workflows

Deep Dive

Cursor

Tab

Cursor's Tab feature is their solution to code autocompletion, replacing their earlier Copilot++ implementation. Unlike GitHub Copilot's insertion-only approach, Tab can modify code around your cursor position, including editing existing lines. It works within a range of one line above to two lines below your cursor.

You interact with Tab suggestions by:

• Pressing Tab to accept
• Using Esc to reject
• Pressing Ctrl/⌘ → to accept word by word
• Simply continuing to type to ignore suggestions

The system watches your keystrokes and cursor movements to make contextual suggestions, though it will sometimes determine no suggestion is needed. This helps prevent noise in the editing process.

Ctrl+K

Ctrl+K (Cmd+K on macOS) serves two main purposes:

1. Generating new code when no text is selected
2. Modifying existing code when text is selected

The command opens a prompt bar where you describe what you want to do. After generation, you can refine your request with follow-up instructions. The changes are presented in a diff view that clearly shows additions and deletions.

By default, Cursor tries to include relevant context like related files and recent views, which you can supplement using @ references to specific files or code sections.

Chat

The chat interface lives in the AI pane opposite your primary sidebar (toggle with Ctrl/⌘ + L). Each chat maintains its context and history, which you can revisit through Previous Chats (Ctrl/⌘ + Alt/Option + L).

The chat's context system works through several mechanisms:

• Default inclusion of the current file (can be disabled)
• @ symbol references for files, folders, code snippets
• Codebase searching (Ctrl/⌘ + Enter or @codebase)
• Web searching (@web)
• Documentation references (@docs)
• Git information (@git for commits/diffs/PRs)

Generated code in chat responses can be applied directly to your files through an "Apply" button, with changes shown in diff format.

Terminal Ctrl+K

In Cursor's terminal, Ctrl+K provides natural language to shell command conversion. It considers your recent terminal history and command context. Commands can be accepted with Esc or executed immediately with Ctrl/⌘ + Enter.

Aider

Core Workflow

Aider operates as a command-line tool that creates an AI pair programming environment in your terminal. You start by pointing it to specific files: aider <file1> <file2> .... These files become part of the "chat session", allowing the AI to see and edit them.

A key principle of Aider is to only add files that need editing - it automatically pulls in context from related files in your repo through its repository mapping system. This keeps the context focused and efficient.

Commands and Control

Aider uses a / command system for operations:

• /add: Add files to the chat session
• /drop: Remove files to free up context
• /diff: Show changes since last message
• /run: Execute shell commands and optionally add output to chat
• /undo: Revert the last AI-made git commit
• /commit: Commit external edits
• /ask: Ask questions without making changes
• /architect: Discuss high-level design before making changes

The tool supports both Emacs and Vim keybindings (activate with --vim flag), and allows multi-line input through several methods:

• Direct paste
• Using { and } as delimiters
• Meta-ENTER for new lines
• /paste command for clipboard content

Git Integration

Git integration is core to Aider's workflow. Every change the AI makes is automatically committed with a descriptive message. This creates a clear history of AI-assisted changes and makes it easy to revert modifications if needed. The /undo command is specifically designed to roll back the last AI commit.

Model Support and Chat Modes

Aider works best with GPT-4 and Claude 3.5 Sonnet but can connect to almost any LLM. It provides different chat modes for different tasks:

• code: Direct code modifications
• architect: Proposes solutions before making changes
• ask: Questions and analysis without code changes
• help: Tool usage guidance

The architect mode is particularly interesting as it uses two LLM calls - one to design the solution and another to implement it, which often produces better results despite being slower.

Cursor vs Aider

The key difference between these tools isn't in their capabilities - both can effectively modify code with AI assistance - but in their approach and workflow.

Workflow

Cursor integrates directly into your IDE. Its features are always available through keyboard shortcuts, and the AI assistance feels like an extension of standard IDE functionality. This makes it particularly suitable for developers who:

• Prefer GUI environments
• Want AI assistance seamlessly integrated into their editor
• Need real-time suggestions while typing
• Work frequently with multiple files in an IDE interface

Aider takes a different approach, treating AI assistance as a focused terminal session. This works better for developers who:

• Prefer command-line interfaces
• Like working in focused sessions rather than continuous assistance
• Appreciate automatic git commits for each AI change

Context Management

Both tools handle codebase context differently:

• Cursor maintains persistent context through its indexing system and provides multiple ways to reference code through its @ symbol system
• Aider focuses on explicit file addition and repository mapping, with a more straightforward but potentially more precise context model

Use Case Optimization

• Cursor excels at quick edits and real-time assistance during normal development work
• Aider shines in focused pair programming sessions where you're working through specific problems or implementing planned changes

GitHub Copilot

Autocomplete

Copilot's core functionality is its autocomplete system. When you type, it shows suggestions in ghosted text that can be accepted with Tab, rejected with Esc, or ignored by continuing to type. You can cycle through alternative suggestions using Alt+[ and Alt-] (or Option+[ and Option-] on Mac).

The suggestions come from analyzing your current file, open editors, and project context. What works particularly well is using comments to get specific implementations. Writing // validate email or // parse json response typically gives you sensible validation or parsing code that matches your project's patterns.

If you want to see multiple suggestions at once, press Ctrl+Enter when a suggestion appears to open a new tab with several alternatives. For more granular control, you can use Ctrl/Cmd+→ to accept suggestions word by word, which is useful when only part of a suggestion matches what you want.

In practice, the autocomplete works best for incremental coding - adding new functions, implementing interfaces, or writing standard patterns like data validation. It's particularly good at matching existing patterns in your codebase, which helps maintain consistency but can also propagate existing anti-patterns if they're present.

Chat Interface

The chat functionality can be accessed in several ways in VS Code:

• Press Ctrl+Shift+I to open the dedicated chat sidebar
• Press Ctrl+I for inline chat directly in your editor
• Press Shift+Ctrl+I to open the quick chat dropdown

To use chat commands:

1. Select some code in your editor
2. Press Ctrl+I to open inline chat
3. Type / to see available commands like /explain, /tests, or /fix
4. Press Enter to execute the command

Alternatively, you can right-click selected code and choose Copilot > Explain or Copilot > Generate Tests from the context menu.

The chat understands context in several ways. It automatically sees your current file's content and can understand selected code. For larger changes or questions about multiple files, you'll need to explicitly share the context through selection or by having relevant files open.

Unlike Cursor's chat which feels more conversational, Copilot's chat is more task-oriented. It works best for specific requests like explaining code, suggesting improvements, or generating tests, rather than open-ended discussions about architecture or design.

GitHub Features

Copilot integrates with GitHub's web interface in several ways:

For pull requests:

1. Navigate to a pull request
2. Click the Copilot icon at the bottom right of the page
3. In the chat panel that opens, you can ask about changes or get a summary
4. For specific file changes, click the Files Changed tab and use the Copilot icon next to any changed file

For issues:

1. Open an issue on GitHub
2. Click the Copilot icon at the bottom right
3. Ask questions about the issue or request suggestions for fixes

For exploring codebases:

1. Navigate to any repository file
2. Click the Copilot icon at the top right of the file view
3. Type questions like "explain this file" or "what does this function do"
4. For specific code sections, select the lines first then click the Copilot icon that appears

These integrations work best when exploring unfamiliar code or trying to understand complex changes. The PR summaries can be particularly helpful for quick code review context, though you'll still want to review the actual changes carefully.

CLI Integration

The CLI works through GitHub's command-line tool. First, you need to:

1. Install the GitHub CLI
2. Install the Copilot extension with gh extension install github/gh-copilot

Then you can use:

• gh copilot suggest "your request" - Get command suggestions
• gh copilot explain "command" - Get explanations for commands

For example:

gh copilot suggest "find large files in current directory"
gh copilot explain "docker ps -a"

When Copilot suggests a command, you can either:

• Press Enter to execute it directly
• Press Tab to modify it before execution
• Press Esc to copy it to clipboard without executing

The CLI integration is particularly useful for complex shell commands that you use infrequently, like specific git operations or system administration tasks.

IDE Support

Copilot works across multiple IDEs through plugins. In VS Code, everything is accessible through keyboard shortcuts or the command palette (Ctrl+Shift+P). The JetBrains implementation uses their standard shortcuts:

• Ctrl+Shift+Space for basic completion
• Alt+\ for next suggestion
• Ctrl+Shift+I for chat

Visual Studio uses Alt+/ for inline chat and maintains a similar UI to VS Code but with Microsoft's standard keyboard mappings.

Neovim integration requires configuration in your init.vim/init.lua and provides basic commands like :Copilot enable and :Copilot disable, with mappings you can customize.

Copilot vs Cursor vs Aider

When writing code incrementally, Copilot's autocomplete is more predictable than Cursor's Tab feature. It suggests code that follows your project's patterns and rarely tries to be too clever. Cursor's suggestions can be more aggressive, sometimes trying to modify multiple lines when you just want to complete the current one.

For larger changes, Copilot falls short of both alternatives. While you can use the chat to request changes, there's no equivalent to Cursor's Ctrl+K command. You end up copying the chat's suggestion and manually applying it, whereas Cursor shows you a clear diff and lets you apply changes with one click. Aider takes this even further with automatic git commits, though it requires switching to the terminal.

Context handling varies significantly between the tools. Copilot works with whatever files you have open - there's no explicit way to tell it "use this file for context but don't modify it." Cursor's @ references give you more control, letting you explicitly point to relevant files or functions. Aider's approach of explicitly adding files to the session is the most straightforward but requires more setup.

The choice often comes down to your specific needs:

• If you mainly want code completion while typing and work across different IDEs, Copilot does this in a very predictable way.
• If you frequently make larger changes and want to stay in a GUI editor, Cursor's Ctrl+K workflow is more efficient. While Cursor's Tab can be more aggressive it also can be more useful. That's more a matter of taste. The great thing is that you can simply try it out. Cursor is a VSCode fork and you can install extensions, e.g. GitHub Copilot.
• If you want explicit git integration and don't mind using the terminal, Aider provides better control over changes. It's a different mode of doing things but can be immensely productive.

Each tool pushes you toward a different workflow. Copilot encourages writing code incrementally with lots of small completions. Cursor works better when you plan larger changes and use Ctrl+K to implement them. Aider works best for focused programming sessions where you explicitly want AI assistance.

What I'm building

Delegate tasks. Get software.

Give Vroni a GitHub issue, bug report, spec, or rough idea. It reads the repo, plans the change, writes code, runs checks, and works toward a review-ready pull request.

Take a look at vroni.com