Why use Aider instead of Claude Code?

Three reasons in practice. One, Aider is model-agnostic — you can route to Claude, GPT, Gemini, DeepSeek, or local models via Ollama with a single config flag. Two, every edit is a git commit, which makes review and rollback genuinely first-class. Three, it is open-source, so there is no SaaS lock-in and the project is easy to audit or modify. The cost is a less polished UX and a smaller ecosystem.

What models work best with Aider?

The Aider docs explicitly call out Claude 3.7 Sonnet, DeepSeek R1 and Chat V3, OpenAI o-series and GPT-4o-class models as the strongest pairings. Local models work too via Ollama or any OpenAI-compatible endpoint, but smaller local models tend to struggle with Aider's edit format. If you are using a frontier model, you are fine; if you are using a small local model, expect some friction.

How is Aider different from just chatting with an LLM and pasting code?

Three things. It maintains a repo-aware context (a "repo map") so the model knows what else exists. It applies edits directly to your files via git rather than producing text you have to copy. And it has structured commands (/add, /drop, /undo, /diff) for managing what the model sees and reverting what it does. Chat with an LLM is a generalist tool; Aider is a CLI specifically shaped for editing a real repo.

How to Use Aider Effectively

Aider tends to get less attention than Claude Code or Cursor because it does not market aggressively, but in a lot of engineering teams it is the third tool in the rotation — the one that gets pulled out when you want maximum control, maximum transparency, or specifically a model that the SaaS tools do not natively serve.

What Aider is

Aider is an open-source command-line AI pair-programming tool, created and maintained by Paul Gauthier at Aider-AI on GitHub. The pitch from the homepage is honest: it lets you pair-program with LLMs to start a new project or build on an existing one.

The shape:

Runs in your terminal. You install it via pip, change into a project directory, and run aider.
Edits real files via git. Every change Aider makes lands as a git commit, with a clear commit message. Reverting an edit is git reset (or Aider's own /undo command).
Model-agnostic. It speaks to Claude, OpenAI, DeepSeek, Gemini, OpenRouter, and any OpenAI-compatible endpoint. Local models via Ollama work too. The Aider docs explicitly recommend Claude 3.7 Sonnet, DeepSeek R1/V3, OpenAI o1/o3-mini, and GPT-4o-class models as the strongest pairings.
Repo-aware. Aider builds a "repo map" — a structured summary of your codebase — and uses it to give the model the right context per query without sending the entire repo every time.

The result is a CLI that does the same job as Claude Code (terminal-native repo-aware coding) but with more flexibility and less polish.

Getting started

Installation, from the docs:

python -m pip install aider-install
aider-install

Then from inside any git repo:

cd /path/to/your/project
aider --model sonnet --api-key anthropic=YOUR_KEY

The --model flag points at your model of choice; --api-key sets the credential. Aider stores config under ~/.aider.conf.yml if you want to make those persistent.

The first time you run it, Aider builds a repo map and shows it to the model. From then on, every prompt you type is sent along with the relevant repo context.

The commands that matter

A handful of slash-commands cover most workflows:

/add — add a file to the current chat session. The model can read and edit it.
/drop — remove a file from the session.
/diff — show the changes Aider has made since the last commit.
/undo — undo the last edit (reverts the commit).
/git — run a git command without leaving Aider.
/test — run a test command and feed the output back to the model.
/help — full command list.

The single most important habit: add only the files you want the model to edit. Aider's repo map gives the model awareness of the whole project, but only files explicitly added are eligible for editing. This keeps changes scoped and reviewable.

Edit modes

Aider has two main edit modes, configurable per session:

Whole-file edits. The model returns the entire updated file; Aider replaces the old one. Simple, robust, expensive on tokens.
Diff-style edits. The model returns a structured diff (SEARCH/REPLACE blocks); Aider applies the patch. Faster, cheaper, requires the model to be precise.

Diff mode is the default for capable models and is what you want most of the time. If you are using a smaller or weaker model and seeing edit failures, fall back to whole-file mode.

A workable session

A typical Aider session looks like this:

$ cd my-project
$ aider --model sonnet

aider> /add src/auth.py src/auth_test.py
aider> Add support for a "remember me" option to the login function.
       It should set a 30-day cookie when checked, and use the
       existing session cookie when unchecked.

# Aider proposes diffs, commits them with a clear message,
# and shows you the changes.

aider> /test pytest src/auth_test.py
aider> The test "test_remember_me_sets_cookie" failed because the
       cookie expiration is wrong. Fix it.

# Aider sees the test output, proposes a fix, commits again.

aider> /diff

# Review everything before pushing.

That loop — scope files, give a task, let Aider commit, run tests, iterate — is the discipline. Engineers who try to use Aider with a kitchen-sink set of files added and a vague request get less out of it than those who treat each task as a small scoped unit.

Where Aider excels

Model choice. You can swap from Claude to DeepSeek to a local Llama with a flag. Useful when you want to compare models on real work, or when a specific model is the right fit for a specific task (DeepSeek for math-heavy code, local models for privacy-sensitive work, Claude for general).
Transparency. Every edit is a commit. The model can never "secretly" change something — you see the diff and the commit message.
Composability with your existing setup. Aider does not replace your editor; it edits files on disk. Your editor sees the changes immediately. You can run Aider in one terminal and your usual editor in another.
Cost control. Because edits are scoped to the files you add, and because diff-mode minimizes token usage, real-world Aider sessions tend to cost noticeably less than equivalent work in a less-scoped tool.

Where it falls short

UX polish. No fancy UI, no inline completions, no editor integration beyond "edits files on disk." If you want a beautiful experience, this is not it.
Onboarding. The command vocabulary takes a session or two to internalize.
Small-model reliability. Aider's edit formats demand precision. Models below the frontier tier (and many local models) struggle to produce clean diffs and fall back to whole-file mode, which is slow and expensive.
Less aggressive agency. Aider waits for instructions more than Claude Code or Cursor's agent mode. If you want "set a goal and walk away," Aider works but is less of a natural fit.

When to reach for Aider

The right times to use Aider over the alternatives:

You want to use a specific model that the SaaS tools do not native-serve (local Llama, DeepSeek, OpenRouter routing).
You want every change to land as a reviewable git commit, with no SaaS in the middle.
You are working on a codebase where transparency about every edit matters — security-sensitive code, regulated environments, anything where you would not trust a tool that hides what it changed.
You want a CLI that drops cleanly into a remote dev environment or a tmux-heavy workflow.

For interactive in-editor coding, Cursor is usually a better fit. For autonomous repo-wide tasks with first-class Claude access, Claude Code is usually a better fit. Aider's spot is the engineer's option for engineers who want to own the model, the workflow, and the commit history.

How to Use Aider Effectively

Article summary