Skip to content
Notifications
Clear all

Switched from GitHub Copilot to Aider, here's my breakdown of wins/losses.

4 Posts
4 Users
0 Reactions
61 Views
(@diego_h)
Honorable Member
Joined: 8 months ago
Posts: 313
Topic starter   [#12039]

I’ve been using GitHub Copilot for about six months, but recently switched to Aider to see if it fits my workflow better. My main goal was better integration with my existing tools and a more focused coding assistant.

The biggest win is how Aider handles git directly. It makes changes and commits them with clear messages, which keeps my history clean. I also like that it works in my terminal, so I can stay in one place. The loss is the lack of direct editor integration like Copilot’s inline suggestions. I sometimes miss that flow when I’m just typing. Overall, it’s great for structured changes but less for real-time brainstorming.


Still learning.


   
Quote
(@jordanh)
Estimable Member
Joined: 4 months ago
Posts: 85
 

Mid-sized shop, running a Go monorepo on bare metal (I know, I know, but cloud bills were getting stupid). We're doing event sourcing with Kafka and a lot of Postgres materialized views. I also work on a side project in Python that does image processing. I've used Copilot since it was in beta, and I've been running Aider for the last two months as my daily driver.

**Pricing vs. hidden cost.** Copilot is a known quantity: $10-19/user/month depending on your business tier. Aider is free, but you pay for the OpenAI API calls. In my env, a typical session of 10-15 chat turns and a few file edits runs about $0.15-0.40. That's cheap for a single dev, but if you're on a team of 10 doing this all day, your monthly bill is going to look like a Copilot subscription anyway. The real hidden cost is the API key management and the fact that you're tied to one model provider unless you start swapping endpoints.

**Integration model.** Copilot lives in your editor. It's a rubber duck that whispers in your ear. Aider lives in your terminal and uses git as its source of truth. That's not a minor difference. If you're the kind of dev who lives in a terminal and treats your editor as a fancy text widget, Aider is a natural fit. If you're the kind of dev who uses inline suggestions as a second brain for method completion, you will miss that flow. I found myself typing `#generate a method that does X` in comments just to get Copilot to fire, and Aider makes you explicitly ask for that.

**Refactoring vs. exploration.** Aider is demonstrably better for structured changes. I gave it a task to refactor a 300-line function that was doing three things into three separate functions, with proper error handling and tests. It did it in one shot, committed with a message like "refactor: extract validation and formatting logic from processOrder". Copilot would have needed me to scaffold that manually and would have left the old code untouched. On the flip side, for quick exploration ("what's the idiomatic way to use a context with timeout in this loop?"), Copilot's inline suggestions give me an answer in the time it takes Aider to even start thinking.

**Where it breaks.** Aider is absolutely brutal on codebases it doesn't understand. If you have a lot of indirection, dependency injection, or heavy use of reflection, Aider will hallucinate function signatures and imports. I watched it try to import a struct that hadn't existed in the codebase for three releases. Copilot is more conservative here because it's constantly training on the context of your current file. Aider also struggles with large files. Anything over 500 lines of Go and the context window fills up with garbage, making it start making ridiculous changes. I had to manually slice up a file for it to handle a 800-line view model.

**Debugging loop.** This is where Aider actually wins for me. The conversation loop lets me say "that didn't work, here's the error" and it will fix its own code. Copilot is a one-shot deal. You get the suggestion, you paste it, it breaks, and you have to manually fix it or ask again. Aider's ability to iterate on its own output feels like pairing with a junior dev who actually listens. It's infuriating and productive in equal measure.

My pick: If you're doing structured refactoring, writing tests, or working on a codebase you know cold, Aider is the better tool. If you're exploring a new framework, writing quick scripts, or just want autocomplete on steroids, stick with Copilot. The real question you should answer is whether you're in a "I know what I want to write" mood or a "what should I write next" mood. Those are different tools.


🤷


   
ReplyQuote
(@catherinew)
Reputable Member
Joined: 4 months ago
Posts: 261
 

> the real hidden cost is the API key management and the fact that you're tied to one model provider

This is a good point. That vendor lock-in gets me thinking. With Copilot, you're paying for convenience, sure, but you're also paying for stability. The price and model are just set.

If OpenAI's API has an outage or a pricing shift, your Aider workflow breaks. How do you even budget for that? It's like trading a flat SaaS fee for a variable utility bill, which my finance team would hate.



   
ReplyQuote
(@alexm82)
Reputable Member
Joined: 4 months ago
Posts: 255
 

That git integration sounds like a killer feature. Does it ever make a commit you disagree with or one that's too granular? I'd worry about cluttering the history with micro-commits.

I also miss the inline suggestions when I'm just trying to draft something out quickly. Have you found a way to work around that, or do you just switch back and forth between tools?



   
ReplyQuote