Aider AI Review

Verified on 16 October 2026 against Aider's documentation, its current PyPI release metadata, and the providers' live documentation and prices. This is a documentation-based evaluation with calculated cost scenarios, not a hands-on coding benchmark. The decision turns on model portability, context control, reviewability, task delegation and total API usage.

What is Aider AI?

Aider is an open-source program that connects a language model to files in your working directory. You describe a change in the terminal; Aider supplies repository context, asks the model for edits, applies them and normally records them in Git, the version-control system that tracks code changes. The client runs locally, but a cloud model still receives the context you send it. Its Apache 2.0 license covers the client; it does not supply a model subscription or make a commercial model open source.

Who should use the Aider AI coding assistant?

Aider suits a developer who can choose the relevant files, recognize a bad patch and run the project's checks. It is especially appealing to a technical founder making occasional changes who wants to pay for model usage only, or an engineer who wants the same editing workflow across different providers.

The comparison below is about documented workflows, not measured coding accuracy. Claude Code is Anthropic's coding agent; OpenAI Codex CLI is a terminal agent with review and delegation tools; Cursor combines an editor with local and cloud agents.

These are relevant entry points, not complete plan ladders or promises of unlimited work. Aider has no cheaper client tier to outgrow: the constraint is the provider account or the machine running your local model.

Choose Claude Code for a broader terminal workflow

Claude Code is the better fit when a request needs more than a patch: investigate a failure, consult an external system, run commands and prepare a pull request. Its official overview documents Git operations, subagents and Model Context Protocol integrations, which connect an agent to external tools and data. Aider can run commands and consume their output, but you do more of the work of assembling that wider workflow.

Skip Claude Code when your main requirement is switching the same client between Claude, Gemini and a local model. Its integrated workflow is useful only if that workflow is what you want to buy; a developer supervising a small patch may prefer Aider's narrower scope. Claude's free plan does not include the Code entitlement listed on Pro.

Choose Codex CLI for review and delegation

Codex CLI has a more extensive documented operational surface: dedicated code review, reusable skills, plugins, subagents, permission controls and a command to hand work to Codex Cloud. Those integrations suit a founder who wants an agent to investigate a repository and then review the result. OpenAI's CLI documentation describes these capabilities directly.

Codex also accepts API-key authentication, so avoiding a subscription does not by itself decide this comparison. The boundary is what comes with that authentication: the API-key route lacks the cloud features of the account-based offering. Choose Aider when provider portability matters more than that integrated review and handoff experience.

Aider vs Cursor: choose the work surface

Cursor is the stronger choice for a developer who wants the agent beside the editor, with code search, terminal execution and browser-based verification in the same interface. Its Agent documentation also distinguishes checkpoints, temporary snapshots for undoing agent changes, from permanent Git history. Aider's automatic commits are a better fit when Git itself is your preferred review surface.

For work that must continue away from your laptop, Cursor Cloud Agents supply isolated virtual machines and artifacts such as screenshots, videos and logs. That is an operating environment Aider's local pair-programming loop does not provide. Cursor's cheaper Plus plan excludes cloud agents, and Premium's third-party model usage is extra. Pay for Cursor when the editor or remote environment removes work you would otherwise maintain yourself.

For a wider shortlist built around source access and deployment choices, use the open-source AI coding agents guide.

Git-native edits make a bounded task easy to review

Aider's strongest workflow is a small requested change followed by a visible diff and a test. Automatic commits create checkpoints in an ordinary repository, so reviewing or undoing the result fits an existing development habit.

How to install Aider

Aider's current installation guide recommends its dedicated installer:

python -m pip install aider-install
aider-install

The installer creates a separate Python environment and can install Python 3.12 for Aider. That distinction matters: the Python running the installer and the Python running the application need not be the same. It avoids making Aider's dependencies part of your application's environment.

The current package is 0.86.2 on PyPI. GitHub's Releases page still labels 0.86.0 as its latest release entry. Use the package version when discussing what the installer distributes; the two pages are not interchangeable release signals.

First task: create a function and its tests

Aider's usage guide starts with a factorial program and permits filenames that do not exist yet. This walkthrough uses that documented pattern, adding a test file so the result has a concrete acceptance check. It is a suggested exercise, not a recorded successful run.

For an existing application, replace the example files with the small set the change needs. A task such as “reject expired reset tokens and add the regression test” is a better starting point than “improve authentication.” The former tells you what a correct diff must demonstrate.

Git history is useful, but check the commit behavior

Aider commits its edits automatically and may first commit your existing uncommitted changes in a file it needs to modify. That keeps human edits separate from generated edits, but it can surprise someone expecting all unfinished work to remain uncommitted. The Git documentation explains this behavior and the switches that control it.

Use --no-auto-commits if you prefer to prepare the final commit yourself. Otherwise, treat the generated commits as a working history that still needs review before merge. An automatic commit is evidence of a recorded change, not evidence that the change is correct.

The repository map helps you find context, not skip it

Aider's repository map is useful because it supplies structure without sending the complete contents of every file. It highlights important classes, functions and call signatures, the names and parameters that show how code connects. A graph-ranking process selects relevant portions of that map for the current conversation. Aider documents a default map budget of 1k tokens, with dynamic expansion in some situations.

Consider a checkout change. The map can reveal that the payment handler calls an existing tax service, helping the model reuse it. It cannot establish the service's rounding behavior merely by showing a function name. If that behavior affects the patch, supply the implementation or the relevant tests.

The practical workflow is to ask where the behavior lives, inspect the suggested files and add only those that should be edited. Use /read-only for supporting material that should inform the answer without joining the editable file set. Use /drop when a file is no longer needed. These are documented in-chat commands.

This gives an experienced developer useful control over scope. It also means that a large repository does not become fully understood because a map exists. The map is a guide to relevant code; the actual behavior still lives in files, configuration, data and tests.

Model choice works when you own compatibility

Aider can connect to a broad range of hosted and local models. Its model documentation also warns that a model can return plausible code while failing to produce edits Aider can apply. “Almost any model” describes connection flexibility, not equivalent coding quality or guaranteed support for every new API feature.

Claude: use an active model ID, not an old shortcut

Aider reads ANTHROPIC_API_KEY, and its Anthropic setup page documents model selection and listing. However, that page still names Claude 3.7 Sonnet as the default. Anthropic retired that model on 19 February 2026. Copying an old example is not a reliable October setup.

With your key already set, the explicit provider route for the active Claude Sonnet 5.5 model is:

aider --model anthropic/claude-sonnet-5-5 \
  --weak-model anthropic/claude-sonnet-5-5 \
  --edit-format diff

This applies Aider's documented provider syntax to Anthropic's current model ID; it is not a tested compatibility claim. If your installed version lacks the model's settings or rejects an API parameter, use Aider's advanced model configuration to supply the appropriate settings. Check both the main and weak model names: updating only the main model can leave auxiliary requests pointed at a retired one.

GPT: set the OpenAI key and choose the model explicitly

Aider reads OPENAI_API_KEY; its OpenAI connection page documents --model and --list-models openai/. The current advanced-settings page includes GPT-5.5 with the diff edit format and repository mapping:

aider --model gpt-5.5 --weak-model gpt-5.5

OpenAI still documents GPT-5.5 API access even though its availability through a ChatGPT-authenticated Codex session is a separate product decision. An API key and a subscription login are different billing and access paths. The cost example below uses API list prices only.

Gemini: use the provider prefix

Aider reads GEMINI_API_KEY. Its Gemini setup instructions document the gemini shortcut; an explicit ID makes the intended model easier to audit:

aider --model gemini/gemini-2.5-pro \
  --weak-model gemini/gemini-2.5-pro

That model has a documented diff-fenced configuration. Choosing it here is a reproducible configuration choice, not a claim that it is Google's newest model or the best model for every repository.

Local models: connect to Ollama

Aider's Ollama instructions recommend the ollama_chat/ prefix. With Ollama installed and its server running, these Bash commands select a model you intend to run locally:

read -r -p 'Ollama model name: ' AIDER_LOCAL_MODEL
ollama pull "$AIDER_LOCAL_MODEL"
export OLLAMA_API_BASE=http://127.0.0.1:11434
aider --model "ollama_chat/$AIDER_LOCAL_MODEL" \
  --weak-model "ollama_chat/$AIDER_LOCAL_MODEL"

Pick a model your hardware can support and check its context configuration. Local inference removes the cloud API token bill for those calls, but hardware, electricity and your operating time remain costs. Keeping the model endpoint local is also different from merely running the Aider client locally.

Modes and edit formats solve different problems

Aider's chat mode determines the kind of interaction; its edit format determines how the model describes file changes. Confusing them leads to an expensive mistake: treating architect mode as a read-only planning mode when it can change files.

The four documented chat modes are:

• code: the default mode, which makes requested code changes.
• ask: discussion and questions without file edits.
• architect: a planning request followed by an editing request, potentially using different models.
• help: questions about using or configuring Aider.

Use /ask with a question for a single read-only message. Use /chat-mode ask to keep subsequent messages in that mode until you switch. For an unfamiliar billing module, discuss the invariant first, then use /code to implement the agreed change. That lets you inspect the plan yourself before edits begin.

Architect mode helps when separating solution design from patch production is useful. It involves two model requests, so it can add latency and cost. A cheaper editor model does not automatically make the complete task cheaper: the planning request, repeated context and retries still count.

The edit-format names are equally specific:

• whole returns each changed file in full. A tiny modification to a long file can therefore require a large response.
• diff returns search-and-replace blocks for the changed regions.
• diff-fenced uses a related format with the filename inside the code fence; Aider primarily uses it with Gemini models.
• udiff uses Aider's simplified variant of a unified diff.
• editor-diff and editor-whole use focused editing prompts for the editor stage of architect mode.

Normally, keep the documented model-specific default. Use --edit-format when you have a concrete compatibility reason, and --editor-edit-format for the architect's editor stage. Switching formats is not a substitute for checking the generated code.

Is Aider free? What API tasks cost

Aider has no client subscription fee. With your own keys, the useful number is the provider charge for all requests needed to reach an accepted patch. There is no defensible universal price for “a bug fix” without knowing the context, output, retries and models used.

For a reproducible comparison, use two models listed in Aider's current model settings: OpenAI GPT-5.5 and Google Gemini 2.5 Pro. These are documented configurations, not a ranking of the newest models. At the makers' standard list rates checked on 16 October 2026:

• GPT-5.5 costs $5 per million input tokens and $30 per million output tokens.
• Gemini 2.5 Pro costs $1.25 per million input tokens and $10 per million output tokens for prompts at or below 200,000 tokens. Its output rate includes thinking tokens.

The following are hypothetical task budgets, not measured task costs. Each row totals every request in one attempt. Assume uncached text, the same model for all calls, ordinary global processing, no paid external tools, no discounts and no taxes. Keep each individual prompt at or below 200,000 input tokens, even when the cumulative total is larger. Count provider-billed output, not just the text visible in the terminal.

The first row's arithmetic is 20,000 / 1,000,000 × $5 + 2,000 / 1,000,000 × $30 = $0.160 for GPT-5.5. For Gemini, it is 20,000 / 1,000,000 × $1.25 + 2,000 / 1,000,000 × $10 = $0.045. The other rows use the same formula with larger aggregate counts.

At the middle budget, 100 attempts in a month would cost $80 or $22.50, respectively. That is a budget projection, not a promise about how many useful changes you will receive. If you use a different weak model for commit messages or another editor model in architect mode, price those calls separately and add them.

Caching can change the bill, and larger individual prompts can trigger different rates. Reconcile against the provider's usage record before making a subscription-versus-API decision. Aider's local cost display is useful feedback, but it is not the invoice.

Where the Aider coding assistant hits its limits

Aider's limitations matter most when an apparently successful edit hides missing validation or incorrect billing assumptions.

Pre-commit hooks are skipped by default. The Git documentation says Aider commits with --no-verify unless you enable --git-commit-verify. A repository's formatting, secret checks or other pre-commit policy may therefore never run during those automatic commits. Enable verification when that policy matters, and keep independent checks before merge. This is a concrete limitation of the default Git workflow, even though the commits themselves are convenient.

Automatic linting is not an automatically configured test suite. Aider lints edited files by default, but automatic tests require a test command and the auto-test option. For the first-task project above, launch with:

aider --model gemini/gemini-2.5-pro \
  --weak-model gemini/gemini-2.5-pro \
  --git-commit-verify \
  --test-cmd 'python -m unittest -v' --auto-test \
  factorial.py test_factorial.py

In a real repository, use its established test command. Aider relies on the command's exit status to detect failure. Its docs also warn that a formatter returning a nonzero status after changing files can be mistaken for a genuine error. A badly configured feedback loop can spend tokens repairing the wrong problem.

Unknown models can display misleading costs. Aider's model-warnings page says an unfamiliar model may be treated as having unlimited context and no token cost. That is a fallback assumption, not free inference. Model metadata can be configured, but the provider remains the billing authority. This matters precisely to the reader choosing Aider for cost control.

You still curate context. Adding every file increases what the model must process without proving it understands the change. Aider's token-limit guidance recommends removing unneeded files and narrowing requests; its counts are estimates, and it reports provider limit errors rather than enforcing those limits itself. A map budget is not a spending cap.

The local editing loop does not provide a managed task service. You can run commands and build automation around Aider, but a remote environment, shared review queue and operational controls require additional work. A developer wanting to supervise a patch can accept that tradeoff. A founder wanting to delegate an investigation overnight should give the managed cloud workflows a serious look.

Verdict: use Aider for a patch you intend to supervise

Aider is a strong choice when you value provider independence, work comfortably in a terminal and want AI edits recorded in ordinary Git history. Start with it for bounded maintenance, small features and refactors whose acceptance criteria you can state and review.

The decision flips when you want to delegate responsibility for navigating the workflow. Choose Claude Code for its integrated terminal and external-tool experience, Codex for its review and cloud handoff, or Cursor for editor-based work and managed remote agents. Paying for those surfaces makes sense when they save more setup and supervision than Aider's flexible client costs you.

For your next working session, take one contained issue, identify its acceptance test, enable the relevant checks and record the provider charge through the final accepted diff. Keep Aider if that loop feels controlled and economical. Switch if configuring models and managing context consume the time you wanted the agent to save.

FAQ

Get the AI Business Workflow Audit Checklist and future practical tool reviews by joining the newsletter.