No subscription. No vendor lock-in. Every AI change is a git commit you can undo, cherry-pick, or audit.

I started using Aider in March 2026 after hitting rate limits on Claude Code's Pro plan for the third time in a week. I was frustrated — I liked the agentic workflow but resented paying $100/month for a tool that locked me to one company's models. Aider promised the opposite: open source (Apache 2.0), any LLM I wanted, pay only for the API tokens I used, and every change committed to git automatically. Six weeks later, across 9 projects (5 Python, 3 TypeScript, 1 Go) and 6 different language models, I've spent $47.30 total in API costs — $7.88 per week, $1.12 per day of active coding.

The TL;DR: Aider is the best value in AI coding tools and the only one that treats git as a first-class citizen rather than an afterthought. But the terminal-only interface and upfront configuration overhead mean it's genuinely not for everyone. If you live in the terminal and want model control, Aider is unmatched. If you want a polished GUI experience, Cursor or Windsurf will make you happier.

The Git-Native Architecture That Changes Everything

Every other AI coding tool treats version control as an afterthought. Cursor has an undo button. Copilot has a diff view. Claude Code will commit if you ask it to. Aider treats git as its core operating system.

Every AI-generated change becomes an atomic git commit with a descriptive message. I didn't appreciate how different this feels until I used it for two weeks. When an AI-generated refactor broke my authentication middleware (which happened twice during testing), I didn't hunt through a stack of undo states or re-read the full session transcript. I ran git log --oneline — which showed me exactly which commit introduced the change — and git revert. Done in 10 seconds. The git audit trail transforms AI edits from something vaguely terrifying into something you can reason about the same way you reason about human-written code.

The repository map is Aider's secret weapon for codebase context. It builds a compressed representation of your entire project — file structure, function signatures, class hierarchies, import graphs — and sends it to the LLM as context. This means the AI understands your project's architecture without reading every file line by line. In my 180-file TypeScript monorepo, Aider correctly identified cross-module dependencies and updated import paths when I asked it to extract a shared utility. It did this with Claude Sonnet 4 as the backend, and it worked on the first try.

Aider also runs automatic linting and testing in a feedback loop. If the AI generates code that fails lint or breaks tests, Aider feeds the errors back to the LLM and asks it to fix them. This is the same pattern Claude Code uses, but Aider had it first — the tool predates Claude Code by two years and pioneered several patterns that have since become standard.

Architect/Editor Mode: Two Models, One Task

Aider's most underrated feature is Architect/Editor mode. Some models (like OpenAI's o3-mini or DeepSeek R1) are exceptional at reasoning about solutions but weak at producing structured file diffs. Other models (like Claude Sonnet or GPT-4o) are fast and accurate at editing code but less thorough at planning. Architect mode pairs them: a reasoning model designs the solution, and an editing model implements it.

I tested 5 Architect/Editor combinations on a set of 8 multi-file refactoring tasks:

• o3-mini (Architect) + Claude Sonnet (Editor): 7/8 tasks correct on first attempt. Best combination I tested. The o3-mini plans were thorough, and Sonnet's diffs were precise.
• DeepSeek R1 (Architect) + Claude Sonnet (Editor): 6/8 correct. R1's reasoning was good but occasionally over-complicated the plan, producing solutions that were correct but needlessly complex.
• Claude Opus solo (no split): 5/8 correct. Opus is powerful enough that the architect/editor split doesn't help much — it thinks well and edits well, but the single-model approach means it occasionally misses structural issues a separate planner would catch.
• GPT-4o (Architect) + GPT-4o (Editor): 4/8 correct. Same-model architect/editor provides no benefit over a single session.
• DeepSeek V3 solo: 3/8 correct. Good enough for simple tasks, not for refactoring.

The cost difference is significant. o3-mini + Claude Sonnet cost me $1.80 for all 8 tasks combined. Claude Opus solo cost me $6.40. For complex refactoring, architect mode is both more accurate and cheaper — you're using an expensive reasoning model for the hard part (planning) and a fast editor for the mechanical part (writing diffs).

The Model Flexibility That No Subscription Tool Matches

Aider works with over 100 LLM providers via LiteLLM. I tested 6 models across my projects:

• Claude Sonnet 4: Best all-rounder. Fast, accurate at producing diffs, costs $3/$15 per million tokens. My default for daily use. $2-4 per coding day.
• Claude Opus 4: Best for complex architectural reasoning. Costs $15/$75 per million tokens. I only use it for difficult problems — $15-40 per heavy day.
• GPT-4o: Comparable to Sonnet, slightly worse at structured diffs in my testing, but included if you already have an OpenAI subscription. $1-3 per coding day.
• DeepSeek V3: The budget champion. $0.27/$1.10 per million tokens. About 70% as capable as Sonnet for routine tasks, at roughly 10% of the cost. I used DeepSeek for boilerplate generation and simple edits, reserving Sonnet for complex work. Under $10/month even with daily use.
• o3-mini: Excellent architect in architect/editor mode. Weak at producing diffs on its own.
• Llama 4 via Ollama (local): Ran on my M3 Max MacBook with 36GB RAM. Workable for small tasks, noticeably slower and less accurate than cloud models. Useful for code that should never leave your machine — I used it for a proprietary data pipeline where sending code to an external API wasn't an option. Total cost: $0 beyond electricity.

The ability to switch models mid-session with /model is genuinely useful. I'd start a session with Sonnet, hit a complex refactoring problem, switch to the architect/editor combo (o3-mini + Sonnet), then switch to DeepSeek for the routine boilerplate that followed. No other tool lets you route different models to different tasks within a single workflow.

Where Aider Falls Short

Three limitations are real and will matter to some developers more than others.

First, the terminal-only interface is a deal-breaker for many developers. There are no inline diffs with accept/reject buttons. No syntax-highlighted suggestions that appear in your editor. You read AI-generated diffs in your terminal, and you accept them by approving git commits. Aider has plugins for VS Code and Neovim, but these are community-maintained and don't provide the polished inline editing experience of Cursor or Windsurf. I'm comfortable in the terminal, so this doesn't bother me. I've watched three colleagues try Aider and abandon it within 30 minutes because "it feels like 1995."

Second, configuration overhead is real. You need to set up API keys, choose a model, configure context file patterns, and write a .aider.conf.yml file to get reasonable behavior. Claude Code and Cursor work out of the box. Aider requires 20-30 minutes of setup before your first useful session. The documentation is thorough but assumes you understand how LLM APIs work. If you don't know the difference between input tokens and output tokens, or why you'd want to set --map-tokens to 4096, the learning curve is steep.

Third, code quality varies dramatically by model choice. This is a feature (you control the model) and a bug (you're responsible for choosing the right one). When I accidentally left DeepSeek V3 as the active model during a complex async refactoring in Python, it introduced a subtle race condition that Sonnet would have caught. Aider's model flexibility means you need to develop judgment about which model to use for which task. Subscription tools abstract this away — you get whatever model the vendor picks, and quality is consistent (for better or worse).

Who Should Use Aider

Use Aider if you want full control over which models you use and switch freely between them. No subscription tool offers this. You can use Claude for quality, DeepSeek for cost, and local models for privacy — all in the same session.

Use Aider if git-native workflow matters to you. If you think in commits and want every AI change tracked as an auditable, reversible entry in your git history, Aider's approach is genuinely better than accept/reject buttons.

Use Aider if you're cost-conscious. $47.30 for six weeks of daily use across 9 projects is less than half the cost of one month of Claude Code Max. If you use DeepSeek as your primary model, your monthly cost could be under $10.

Skip Aider if you want a polished GUI. Cursor and Windsurf provide inline diffs, visual editing, and one-click install. Aider provides a terminal and a config file. The experience is powerful but not polished.

Skip Aider if you don't want to think about model selection. Part of Aider's value is model flexibility. Part of its cost is the mental overhead of managing that flexibility. If you want one model, one price, and no decisions, Claude Code or Copilot is simpler.

The Bottom Line

Aider is the most underrated tool in the AI coding landscape. It's open source, model-agnostic, git-native, and costs nothing beyond API fees. Its terminal-only interface will filter out GUI-first developers, but for the subset of developers who live in the command line and want control over their AI stack, nothing else competes.

After six weeks, Aider has replaced Claude Code for about 70% of my terminal-based AI coding. I still use Claude Code for the most complex autonomous refactoring (its self-verification loop is better), but Aider handles my daily pair programming: "add error handling to these 4 endpoints," "extract this shared logic into a utility," "add types to this untyped Python module." For $1.12/day, that's the best deal in AI coding tools.

---

Originally published at pickuma.com. Subscribe to the RSS or follow @pickuma.bsky.social for new reviews.