# Aider

> Source: https://aiwiki.ai/wiki/aider
> Updated: 2026-06-21
> Categories: AI Tools & Products, Developer Tools, Open Source AI
> From AI Wiki (https://aiwiki.ai), a free encyclopedia of artificial intelligence. Quote with attribution.

Aider is an open-source AI pair programming tool that runs in the terminal and integrates directly with [Git](/wiki/git).[1] Created by [Paul Gauthier](/wiki/paul_gauthier) and first released in April 2023, it lets developers converse with [large language models](/wiki/large_language_model) (LLMs) to write, edit, and refactor code across any codebase.[1][3] Unlike editor extensions or standalone AI IDEs, Aider operates entirely from the command line and treats every AI-generated change as a conventional Git commit, giving developers a clean, auditable history of what the model did.[9] By mid-2026 the GitHub repository had accumulated roughly 46,500 stars and 4,600 forks across 93 tagged releases (the latest stable version, v0.86.2, shipped on 12 February 2026), with the project homepage reporting over 6.8 million pip installs and roughly 15 billion tokens processed by Aider users each week.[2][1][41]

Aider sits in a category of [agentic coding tools](/wiki/agentic_coding) that emerged after the release of [GPT-4](/wiki/gpt_4) in early 2023. It is most often compared to [Claude Code](/wiki/claude_code), [Cline](/wiki/cline), [Cursor](/wiki/cursor), and [GitHub Copilot](/wiki/github_copilot), but its design priorities are distinctly different: terminal-first, model-agnostic, Git-native, and explicitly bring-your-own-key.[37] Its [Aider Polyglot](/wiki/aider_polyglot) benchmark has become one of the most-cited evaluations of LLM coding ability.[7]

## Overview

Aider is a [command-line interface](/wiki/command_line_interface) program written in [Python](/wiki/python_programming_language) that exposes a chat-style prompt for editing source code with an LLM.[1] The user opens a session inside a Git repository, optionally adds a few files to the session, and then types instructions in plain English. The model is responsible for proposing code changes in one of several edit formats. Aider parses those changes, applies them to the working tree, runs any configured linters or tests, and commits the result with a descriptive message.[9] The same loop runs on every turn until the user types `/exit` or `/quit`.

The philosophy behind the design is that the developer remains the editor of record. Aider does not run autonomous loops that touch many files without permission. It does not vendor a particular model or charge a subscription. The Apache 2.0 license keeps the codebase modifiable, and the bring-your-own-key model keeps cost under the user's direct control.[2] The tool's daily workflow is built around three primitives: chat with the model, apply changes through Git, and review the diff before the next turn.

The project is maintained by Aider AI, a small organization that grew out of Paul Gauthier's personal project. Development happens entirely in the open on GitHub at github.com/Aider-AI/aider, with releases approximately every one to three weeks.[2] The project notably ate its own dog food: at least 60-88% of code in recent releases was written by Aider itself, with the (aider) commit suffix tagging which commits were AI-authored.[17]

## History

Paul Gauthier is a veteran engineer with roots in the early commercial internet. He co-founded [Inktomi](/wiki/inktomi) in January 1996 with University of California, Berkeley professor [Eric Brewer](/wiki/eric_brewer), serving as the company's founding chief technology officer.[29][16] While a PhD student at UC Berkeley, Gauthier invented Inktomi's distributed-memory parallel search engine, one of the first to scale with the explosion of the web.[29] Inktomi was acquired by Yahoo in 2003 for roughly $235 million.[29] Later in his career he held roles as founding CTO of Ludic Labs (2006-2011), CTO of Groupon (2010-2013), and Technical Fellow at Geomagical Labs (2019-2024), where he developed computer vision technology for augmented reality applications that IKEA acquired in 2021.[16][30]

Gauthier started building Aider in April 2023, shortly after the widespread release of [GPT-4](/wiki/gpt_4) made it plausible that an LLM could reliably produce working code patches.[3] The earliest versions used [ctags](/wiki/ctags) (and later [Tree-sitter](/wiki/tree_sitter)) to build lightweight indexes of a repository, giving the model enough context to understand a codebase without pasting every file into the prompt.[3][4] Gauthier published the project under the Apache 2.0 license on GitHub at the path paul-gauthier/aider, later migrated to the Aider-AI/aider organization.[2]

Early milestones include the introduction of GPT-3.5-turbo support, a benchmarking harness for measuring edit-format correctness, and the Tree-sitter-powered repository map introduced around version 0.16 in 2023.[4][8] Voice-to-code was added in v0.12.[13] The architect/editor dual-model workflow arrived in v0.58, and IDE watch-file integration came in v0.67.[6][20] The project publishes a detailed HISTORY.md tracking every release.[8]

In May 2023 Gauthier wrote about using ctags to improve GPT-4's codebase understanding.[3] By October 2023 the approach had been redesigned around Tree-sitter with a PageRank-based relevance graph.[4] In December 2023 a blog post showed that unified diffs reduced GPT-4 Turbo's lazy coding behavior by about 3x.[5] Through 2024 and into 2025, Aider consistently appeared near the top of coding benchmarks, and in January 2025 the combination of [DeepSeek R1](/wiki/deepseek_r1) as architect and [Claude 3.5 Sonnet](/wiki/claude_3_5_sonnet) as editor set a state-of-the-art score on the Aider Polyglot benchmark.[15]

### Timeline of notable releases

The project releases frequently, with most versions shipping within days to a week of each other. The following table captures the milestones that shaped Aider's current feature set.

| Version | Approximate date | Notable change |
|---|---|---|
| v0.1 | April 2023 | Initial public release with GPT-3.5 and GPT-4 support and the search/replace edit format |
| v0.12 | Mid 2023 | Voice-to-code via Whisper introduced through the `/voice` command |
| v0.16 | Late 2023 | Tree-sitter repository map replaces ctags, adds PageRank-based scoring |
| v0.24 | Early 2024 | `/web` command scrapes a URL and adds its content to the chat |
| v0.31 | 2024 | Browser-based UI (`--browser`) launches alongside the CLI |
| v0.36 | 2024 | Automatic lint and test execution after edits with `/lint` and `/test` |
| v0.42 | 2024 | Performance improvements deliver roughly 5x faster startup |
| v0.44 | 2024 | Reduced install size 3-12x via optional dependency extras |
| v0.51 | Mid 2024 | Anthropic prompt caching for system prompt, repo map, and `/read-only` files |
| v0.58 | September 2024 | Architect/editor dual-model mode goes live |
| v0.60 | Late 2024 | Claude 3.5 Sonnet becomes the default model |
| v0.62 | Late 2024 | Claude 3.5 Haiku reaches 75 percent on the leaderboard |
| v0.67 | Late 2024 | `--watch-files` adds editor-native AI comment workflow |
| v0.70 | Late 2024 | Full support for OpenAI's o1 reasoning models |
| v0.79 | Mid 2025 | Gemini 2.5 Pro support |
| v0.80 | Mid 2025 | OpenRouter OAuth integration for one-click multi-provider keys |
| v0.84 | 2025 | Claude Sonnet 4 and Claude Opus 4 series support |
| v0.85 | Mid 2025 | o3-pro, Responses API models, Gemini 2.5 Pro thinking-tokens controls, repo-map and lint support for Clojure and MATLAB |
| v0.86 | August 2025 | Full GPT-5 family support across OpenAI, Azure, and OpenRouter, plus xAI Grok-4 and Gemini 2.5 Flash-Lite |
| v0.86.1 | Late 2025 | `reasoning_effort` setting for the GPT-5 family, temperature disabled by default for GPT-5 |
| Main branch (post-v0.86.1, late 2025/2026) | Ongoing | Claude 4.5/4.6 with refreshed `sonnet`/`haiku`/`opus` aliases, Gemini 3 preview, DeepSeek Reasoner, GPT-5.1/5.2/5.3/5.4 and GPT-5-Pro variants, `/ok` shortcut, `/context` mode, repo-map tags for Fortran, Haskell, Julia, and Zig |

Gauthier publishes detailed write-ups for several of these releases on the project blog at aider.chat/blog, including benchmark numbers, sample sessions, and the reasoning behind each change.[1] The blog archive through 2025 includes Qwen3 benchmark results (May 2025), a Gemini 2.5 Pro cost correction (May 2025), and a January 2025 post on alternative DeepSeek V3 providers.[15]

## How do you install and use Aider?

Aider is distributed as a [Python](/wiki/python_programming_language) package on PyPI under the name `aider-chat` and a thin installer wrapper `aider-install`.[18] The recommended installation path depends on whether the user prefers an isolated environment, a global tool, or running Aider inside a managed environment.

The official one-command installer uses [uv](/wiki/uv_python), the fast Rust-based Python package manager.[18] Running `python -m pip install aider-install && aider-install` creates an isolated Python environment for Aider, installs all dependencies including the optional Whisper audio support, and adds an `aider` shim to the user's path.[18] A single `uv tool upgrade aider-chat` command keeps it current. The older alternative is [pipx](/wiki/pipx) via `pipx install aider-chat`, which achieves the same isolation with the more familiar pipx tool. A direct `pip install aider-chat` also works, although it installs into whichever Python environment is active.[18]

Aider runs on macOS, Linux, and Windows, with Python 3.10 or newer as the only hard requirement.[18] The voice feature additionally needs the `portaudio` system library, which is installed via Homebrew on macOS or the appropriate package manager on Linux.[13] Windows users typically rely on built-in audio support, although some configurations require manual setup.

After installation, the user navigates into the root of any Git repository and runs `aider`. Aider checks for API keys in the environment or in a `.env` file at the repo root, prompts for one if missing, then opens an interactive chat.[18] The session starts in code mode by default, ready to accept instructions.[11]

At first launch, the user describes a feature, asks a question, or adds files for editing with `/add`.[19] The model receives the prompt, the repository map, and the contents of any added files. It responds with a natural-language explanation followed by edit blocks. Aider applies the edits, runs any configured linter or test, and stages a commit. For non-interactive use, the `--message` flag sends a single message and exits, which is convenient for shell scripts, CI workflows, and bulk refactoring jobs.[22]

## How does Aider work?

Aider is invoked from a shell. After installation with pip or uv, the command `aider` opens an interactive chat session inside the current Git repository.[18] The user types natural-language instructions and Aider responds by editing files and committing the changes.[1]

The core loop is straightforward. The user describes what they want. Aider assembles a prompt that includes the user message, a compact repository map, and the full content of any files the user has explicitly added to the session.[10] It sends that prompt to the configured LLM. When the model returns a response containing code edits in Aider's expected format, Aider applies those edits to the source files on disk, stages them, and creates a Git commit.[9] If the model returns text that does not parse cleanly as a valid edit, Aider will try to recover by re-prompting.[12]

The Git integration is the defining architectural choice. Every change Aider makes becomes a commit, so the developer always has a safety net: `git diff` shows exactly what changed, and `/undo` (or `git reset`) reverses the last AI action instantly.[9] Commit messages follow the Conventional Commits specification by default.[9] Aider appends `(aider)` to the Git author and committer fields so the provenance of AI-generated commits is visible in the log.[9] An optional `Co-authored-by` trailer can be added instead. If the working tree has unstaged changes when Aider starts, it commits those separately before making its own edits, keeping user work and AI work distinct.[9]

Aider supports a watch-file mode for IDE integration. When launched with `--watch-files`, it monitors the repository for AI comment markers added inside code editors.[20] A developer can type a `# AI:` comment in [VS Code](/wiki/visual_studio_code) or any other editor, save the file, and Aider will detect the comment and act on it without the developer switching to the terminal.[20]

## Edit formats

Aider communicates with the LLM through several different edit formats. The format determines how the model is asked to represent code changes, and the choice affects both reliability and token efficiency.[12] Aider selects the optimal format automatically based on which model is in use, but developers can override with the `--edit-format` flag.[12]

### Whole format

The whole format is the simplest approach. The model returns the complete, updated contents of every file it wants to change. Aider replaces the on-disk files with those new versions and commits.[12] The format is robust because it requires no special parsing: if the model returns valid file contents, the edit succeeds. The tradeoff is cost and latency. Even a one-line change forces the model to reproduce the entire file, which wastes tokens on large files. This format is often used for smaller or less capable models.[12]

### Diff format (search/replace)

The diff format instructs the model to return edits as a series of search-and-replace blocks. Each block specifies a chunk of text to find and the text to substitute in its place.[12] Aider matches the search string against the file content and applies the replacement. If the search string does not match exactly, Aider uses fuzzy matching to locate the intended location.[12] Search/replace is generally the most effective format for capable models because each replacement is independent: a mismatch in one block does not cascade to invalidate others. It also avoids the line-number fragility of unified diff formats. This is the primary format used for frontier models such as Claude Sonnet and GPT-4o.[12]

### Udiff format

The udiff format is based on the standard unified diff format but simplified and modified. The model returns only the changed sections of a file in the `@@ ... @@` hunk syntax familiar from `git diff` output.[5] Aider introduced this format primarily for the GPT-4 Turbo family of models, whose tendency to replace large sections of code with placeholder comments ("lazy coding") was significantly reduced when they were constrained to write precise diffs.[5] A December 2023 benchmark showed the udiff format reduced lazy responses by approximately 3x for that model family.[5]

### Diff-fenced format

This is a variant of the diff format in which the file path appears inside the fenced code block rather than before it.[12] It was introduced for the Gemini family of models, which frequently failed to produce correctly structured fences using the standard diff format. The content is otherwise equivalent.[12]

### Edit format benchmark history

Format selection has measurable impact on benchmark performance. When Aider's laziness benchmark was first published in December 2023, GPT-4 Turbo scored only 20 percent with the search/replace format because it tended to elide large code blocks with placeholder comments.[5] The new udiff format raised the same model to 61 percent on the same benchmark, a roughly 3x improvement.[5] The original GPT-4 (June 2023 snapshot) jumped from 26 percent baseline to 59 percent with udiff for similar reasons.[5]

A broader 2025 study (Diff-XYZ benchmark) found that search/replace is the strongest format for generating edits with most large models, while structured udiff variants score better on faithfully applying edits with smaller models.[36] Diff-style formats are dramatically more token-efficient than whole-file rewrites, at the cost of occasional fuzzy matches that need a second attempt to apply correctly.[36]

## Repo map

One of the most technically distinctive parts of Aider is its repository map system. When a developer starts a session in a large codebase, it is not practical to include every source file in the prompt. The context window would overflow, and cost would be prohibitive. At the same time, the model needs enough structural awareness to navigate the code and understand relationships between modules.[10]

Aider solves this with an automatically generated, dynamically sized repository map.[10] The map is a compact textual summary of the entire Git repository that lists the most important symbols (functions, classes, methods) across all files, along with their signatures, but not their full bodies.[10] This gives the model the same kind of orientation a human developer gets from reading an API index: it can see what exists and where, which tells it which specific files to request in full when it needs them.

The map is built in three stages. First, Aider uses Tree-sitter to parse every source file into an abstract syntax tree (AST). Tree-sitter is a parser-generator library that supports more than 100 programming languages; Aider ships query files for each language that specify how to extract definitions and references from the AST.[4][35] The result is a set of tags: each tag records a symbol name, its kind (definition or reference), its file, and its line number.[35]

Second, Aider constructs a directed graph where each source file is a node and edges connect files that share symbols (one defines a symbol that another references).[35] The graph edges are weighted by several factors. Files currently open in the chat carry a 50x weight multiplier. Well-named identifiers and identifiers mentioned in the conversation carry a 10x multiplier.[35] The graph is then scored with a PageRank-like algorithm (using NetworkX's implementation) with the chat files as the personalization set.[4][35] Files and symbols most relevant to the current conversation rise to the top.

Third, Aider selects the highest-ranked symbols that fit within a configurable token budget (defaulting to 1,024 tokens, adjustable via `--map-tokens`).[10] The budget expands dynamically when no files have been added to the chat: in that state, Aider needs more ambient context and allocates a larger slice of the context window to the map.[10] When many files are already open, the map shrinks to make room.[10]

The practical effect is that Aider can handle repositories of hundreds of thousands of lines of code without overwhelming the context window. The LLM receives a structured overview that lets it understand the codebase's architecture at a glance and identify which files to request next.[10]

The approach has been influential beyond Aider. It has been adapted into standalone tools (such as the open-source RepoMapper) and is widely considered a baseline for context engineering in code agents.[34]

For extremely large monorepos, Aider supports two ways to narrow its attention. The `--subtree-only` flag tells Aider to ignore everything outside the current working directory.[10] The `.aiderignore` file uses `.gitignore` syntax to exclude specific paths or globs from the repo map.[10] Both reduce parsing time, repo map size, and token cost, and they reduce the chance that the model gets distracted by unrelated code. The `--add-gitignore-files` flag, added on the post-v0.86 main branch, takes the opposite direction and selectively re-includes files normally hidden by `.gitignore` (such as generated build artefacts or vendored dependencies) when they are needed for a particular task.[46]

Tree-sitter language support has expanded steadily as the project has grown. Aider v0.85 added repo-map and linting support for [Clojure](/wiki/clojure) and MATLAB.[8] Post-v0.86 builds added tag extraction for [Fortran](/wiki/fortran), [Haskell](/wiki/haskell), [Julia](/wiki/julia), and [Zig](/wiki/zig), and improved kebab-case identifier recognition so that languages such as Clojure and Lisp produce cleaner maps.[46] The repo map also incorporates a refinement on the post-v0.86 branch that makes the PageRank graph more robust against circular symlink loops in vendor directories, fixing a class of crashes reported by users with large `node_modules` trees.[46]

## Architect mode

Architect mode is a dual-model workflow introduced in Aider v0.58 (September 2024).[6] As Gauthier put it when announcing the feature, "Because this all happens in a single prompt/response round trip to the LLM, the model has to split its attention between solving the coding problem and conforming to the edit format."[6] The central observation behind it is that asking a single model to simultaneously reason about a hard coding problem and produce output in a rigid edit format divides its attention. Reasoning-focused models (such as OpenAI's o1 and o3 series) are excellent at working through complex problems but sometimes struggle to emit perfectly formatted diffs. Editing-focused models can reliably produce clean edit blocks but may not reason as deeply about architecture.[6]

In architect mode, Aider sends the request to two models in sequence. The first model acts as the architect. It analyzes the problem and proposes a solution in natural language, without any constraint on output format. The second model acts as the editor. It receives the architect's proposal and translates it into properly formatted edit instructions that Aider can apply to files.[6] This lets each model focus on what it does best.

The mode is invoked by passing `--architect` on the command line or switching to it with `/architect` during a session.[11] The architect model defaults to the main configured model; the editor model defaults to a separate, often cheaper, model configured via `--editor-model`.[6] A typical high-performance pairing uses o1 or o3 as the architect and Claude Sonnet or GPT-4o as the editor. The `--auto-accept-architect` flag (default: true) suppresses per-change confirmation prompts.[6]

Benchmark results published with the feature's introduction showed that the o1-preview + o1-mini architect/editor combination achieved an 85% pass rate on Aider's coding benchmark, a meaningful improvement over single-model baselines.[6] The o1-preview + Claude Sonnet combination scored 82.7%, and pairing Sonnet with itself as both architect and editor scored 80.5%, compared to Sonnet's solo baseline of 77.4%.[6]

As of early 2025, the combination of [DeepSeek R1](/wiki/deepseek_r1) as architect and Claude 3.5 Sonnet as editor was the top-ranked configuration on the Aider Polyglot benchmark at the time, demonstrating that cost-effective models can exceed frontier single-model performance when split across two complementary roles.[15]

Architect mode does not always cost more than single-model use. The editor model is typically smaller and cheaper, and the architect only needs to produce natural language. The DeepSeek R1 + DeepSeek V3 pairing scored 59.1 percent on the polyglot benchmark for a total cost of $6.33, comparable to o1 at a fraction of o1's price.[15] Developers can pick the architect/editor combination that matches their accuracy and budget targets independently.

## Voice coding

Aider includes a built-in voice-to-code feature accessible through the `/voice` command during any chat session.[13] When the user types `/voice`, Aider begins recording audio from the system microphone. The user speaks their coding instruction naturally, then presses Enter. Aider transcribes the speech using OpenAI's [Whisper](/wiki/whisper) API and injects the transcribed text into the chat session exactly as if the user had typed it, after which normal code editing proceeds.[13]

The feature requires an active internet connection and an [OpenAI](/wiki/openai) API key for the Whisper transcription, even when using a different provider for the main LLM interaction.[13] It also requires the `portaudio` system library for audio recording. On [macOS](/wiki/macos), this can be installed with [Homebrew](/wiki/homebrew); on [Linux](/wiki/linux), with the system package manager.[13]

Voice coding is useful when typing is inconvenient or when dictating long, complex instructions is faster than typing them. Technical terms, library names, and code-specific vocabulary tend to transcribe accurately because Whisper was trained on a large corpus that includes programming material. The feature was introduced around version 0.12 in 2023.[8]

## Supported models

Aider uses the `litellm` library as its LLM abstraction layer, which gives it access to virtually any major model API without requiring provider-specific integration code.[26] The following table lists models with first-class support and their primary use cases in Aider.

| Provider | Models | Notes |
|---|---|---|
| Anthropic | Claude 3.7 Sonnet, Claude 3.5 Sonnet, Claude 3 Opus, Claude Sonnet 4, Claude Opus 4, Claude Sonnet 4.5 / 4.6, Claude Opus 4.5 / 4.6, Claude Haiku 4.5 / 4.6 | Top overall performers; the `sonnet`/`opus`/`haiku` aliases on the main branch point at the 4.5/4.6 generation and Claude Sonnet remains the default recommendation for many users |
| OpenAI | GPT-4o, GPT-5 (low/medium/high), GPT-5.1, GPT-5.2, GPT-5.3, GPT-5.4, GPT-5-Pro, o1, o1-pro, o3, o3-mini, o3-pro | GPT-5 leads the Aider Polyglot leaderboard; the o- and GPT-5-Pro series excel in architect mode and benefit from Aider's `reasoning_effort` and Responses API plumbing |
| Google | Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.5 Flash-Lite, Gemini 2.0 Flash, Gemini 3 preview | Gemini 2.5 Pro is near the top of the leaderboard; main-branch builds add Gemini 3 preview entries and tagged thinking-token budgets |
| DeepSeek | DeepSeek R1, DeepSeek V3 / V3.2, DeepSeek Chat, DeepSeek Reasoner | Highly competitive at significantly lower cost; the Reasoner model ships with updated metadata and prompt-caching support |
| xAI | Grok-4 | Added in v0.86 via `xai/grok-4` and `openrouter/x-ai/grok-4` |
| Mistral | Mistral Large, Codestral | Codestral optimized for code tasks |
| Cohere | Command A | Supported via direct API |
| Groq | Llama 3.1, Mixtral | Fast inference for interactive use |
| Local (Ollama) | Any model served via Ollama | No API key required; runs entirely on local hardware |
| OpenRouter | Any model on the platform | Single key for multi-provider access, including the Kimi K2 and Moonshot AI families |
| GitHub Copilot | OpenAI, Anthropic, Google models on the Copilot platform | Reuses a Copilot subscription via an OAuth token; see [GitHub Copilot integration](#github-copilot-integration) below |

The `--model` flag selects the model. Aider reads API keys from environment variables (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, etc.) or from a `.env` file. Configuration can also be written to a `.aider.conf.yml` YAML file in the project root or home directory.[21]

For each well-known model, Aider ships a pre-configured metadata file that specifies the optimal edit format, context window size, cost per token, and any special handling.[26] For unknown models, Aider falls back to sensible defaults and allows manual override.[26]

### Local and self-hosted setups

[Ollama](/wiki/ollama) is the most common path for running Aider against fully local models, including [Llama 3](/wiki/llama_3), [Qwen 2.5 Coder](/wiki/qwen_coder), [DeepSeek Coder](/wiki/deepseek_coder), and various distilled variants. Performance with local models depends entirely on the model and the user's hardware. [LM Studio](/wiki/lm_studio) and any OpenAI-compatible HTTP endpoint can also be used directly, which suits organizations that cannot send code over the public internet. [OpenRouter](/wiki/openrouter) provides a single API key that fans out to dozens of providers, including several free tier options. Aider added one-click OpenRouter OAuth integration in v0.80.[8]

### Model aliases and metadata

Aider ships a `.model-settings.yml` file with optimal defaults for hundreds of named models (edit format, context window, cost per million tokens, and tags such as `lazy` or `reasoning`).[26] Users override defaults locally with `--model-settings-file` and use short aliases like `sonnet`, `4o`, `r1`, and `gpt5` to avoid long names.[26] On the post-v0.86 main branch, the `sonnet`, `haiku`, and `opus` aliases were retargeted at the Claude 4.5/4.6 generation, while `flash` and `gemini` now point at Gemini 2.5 Flash and Gemini 2.5 Pro respectively.[46] The metadata file also tags reasoning-capable models so that Aider can drive their thinking-token budgets automatically.[26]

### GitHub Copilot integration

Because [GitHub Copilot](/wiki/github_copilot) exposes a standard OpenAI-style HTTP endpoint at `https://api.githubcopilot.com`, Aider can reuse a Copilot subscription as a model provider rather than billing a separate API key.[42] The integration works by extracting the Copilot OAuth token (typically generated by signing in through a [JetBrains](/wiki/jetbrains) IDE such as PyCharm or GoLand and reading the token out of `~/.config/github-copilot/apps.json`) and then setting Aider's OpenAI-compatible base URL to the Copilot endpoint with that token in place of an API key.[42] After authentication, the user can list the models the Copilot plan grants access to (typically a mix of OpenAI, Anthropic, and Google models) and reference them in Aider by prefixing the model ID with `openai/`, for example `openai/gpt-4o` or `openai/claude-3.7-sonnet-thought`.[42] Aider's documentation cautions that tokens minted by some plugins (such as the Neovim `copilot.lua` integration) may lack the required scopes; in that case, regenerating the token from a JetBrains IDE is the recommended workaround.[42] The integration lets organisations that already pay for Copilot consolidate billing through GitHub instead of opening new vendor relationships, at the cost of any Copilot policies (such as content filtering or usage caps) applying to Aider traffic as well.

### Reasoning and thinking-token controls

As frontier models increasingly expose explicit reasoning controls (OpenAI's GPT-5 and o-series accept a `reasoning_effort` level of `low`, `medium`, or `high`, while Anthropic's Claude reasoning models and Google's Gemini 2.5 series accept a "thinking-tokens" budget), Aider added matching configuration knobs.[26] The `--reasoning-effort` flag (and the in-chat `/reasoning-effort` command) sets the effort level for the active session.[22] The `--thinking-tokens` flag (and the `/think-tokens` command) sets the budget in tokens, and on the post-v0.86 main branch the budget can be set to zero to disable thinking entirely on models that previously enabled it by default.[46] Aider v0.86.1 also disabled temperature for the GPT-5 family by default, since GPT-5 does not honour the parameter, and added a per-model `reasoning_effort` default so users do not have to set it on every invocation.[46]

## What is the Aider Polyglot benchmark?

Aider maintains its own coding benchmark, the [Aider Polyglot](/wiki/aider_polyglot), to evaluate LLM performance on code editing tasks representative of real-world pair programming.[14] The benchmark consists of 225 challenging exercises drawn from the [Exercism](/wiki/exercism) platform, spanning six programming languages: [C++](/wiki/cpp), [Go](/wiki/go_programming_language), [Java](/wiki/java), [JavaScript](/wiki/javascript), [Python](/wiki/python_programming_language), and [Rust](/wiki/rust_programming_language).[14] The diversity of languages tests both reasoning ability and familiarity with language-specific idioms.

Each model receives two attempts per exercise. After a failed first attempt, the model is shown the test failure output and given a second chance to correct its code.[14] The primary metric is the percentage of exercises solved across both attempts. The benchmark also tracks edit format correctness (whether the model's response could be parsed as valid edits) and cost per exercise.[7]

The benchmark is run through Aider itself, making the harness directly representative of how the models perform in actual use.[14] Results are published on the Aider leaderboard at aider.chat/docs/leaderboards/.[7]

### Current top results

As of the leaderboard's November 2025 update, the rankings are led by GPT-5 (high reasoning) at 88.0 percent for $29.08 per run, followed by GPT-5 (medium) at 86.7 percent, o3-Pro (high) at 84.9 percent, and Gemini 2.5 Pro Preview (06-05, 32k thinking) at 83.1 percent.[7] DeepSeek V3.2 hits competitive accuracy at a fraction of frontier cost. The R1 + Claude 3.5 Sonnet architect/editor combo set a state-of-the-art record in January 2025 before GPT-5's release.[15]

| Rank | Model | Score | Cost per run | Edit format |
|---|---|---|---|---|
| 1 | GPT-5 (high reasoning) | 88.0% | $29.08 | diff |
| 2 | GPT-5 (medium reasoning) | 86.7% | $17.69 | diff |
| 3 | o3-Pro (high) | 84.9% | $146.32 | diff |
| 4 | Gemini 2.5 Pro Preview (32k think) | 83.1% | $49.88 | diff-fenced |
| 5 | GPT-5 (low) | 81.3% | $10.37 | diff |
| 6 | o3 (high) | 81.3% | $21.23 | diff |

The leaderboard tracks several auxiliary metrics in addition to pass rate. "Format error" counts cases where the model produced output that Aider could not parse as a valid edit. "Syntax error" tracks invalid code that broke the build before tests even ran. "Indentation error" specifically counts whitespace-related mismatches that defeated fuzzy matching. "Timeouts" captures the proportion of runs where the model exceeded the configured wall clock budget.[7] These additional columns make the leaderboard useful for diagnosing why a particular model underperformed rather than just ranking the totals.

### Code editing benchmark

Aider also maintains a separate "code editing" leaderboard at aider.chat/docs/leaderboards/edit.html.[7] This older benchmark focuses on a smaller exercise set used to evaluate how reliably a model produces valid edits in a chosen format. The code editing benchmark is more sensitive to format-handling regressions and is used during model release testing to verify that a new edit format change has not broken any previously working configuration.

Because Aider publishes its benchmark methodology and the underlying exercise set openly (github.com/Aider-AI/polyglot-benchmark), the results are reproducible and have been cited in external evaluations of LLM coding ability.[14] Independent benchmarks from llm-stats.com, Vellum, Iternal AI, and LM Council all republish or reference Aider Polyglot numbers in their model comparisons, which has made the benchmark one of the de facto standards for evaluating coding LLMs.[27]

## Lint and test integration

Aider can run the project's linter and test suite automatically after every code change. When linting is enabled via `--lint` (and optionally configured with `--lint-cmd`), Aider runs the linter after each edit. If the linter reports errors, Aider reads the error output, attempts to fix the violations, and re-runs the linter.[24] This loop continues until the linter passes or Aider exhausts a configured number of retries.[24]

The test loop works similarly. The `--test` flag (paired with `--test-cmd` to specify the command) causes Aider to run the test suite after each change.[24] Test failures are fed back to the model as context so it can diagnose and fix the broken code without developer intervention.[24] The model sees the exact test failure messages, stack traces, and assertion errors, giving it the same debugging signal a human would have.

These loops are particularly useful for autonomous coding sessions where the developer wants to describe a goal and let Aider work through implementation and verification without constant oversight. The pattern matches the behavior of formal AI software engineering agents but keeps the developer in control: Aider stops and asks for help if it cannot fix an error after repeated attempts.[24]

The linting integration uses Tree-sitter for a language-aware parse step that can detect syntax errors before even running an external linter, providing faster feedback on structurally invalid code.[24]

Users typically set the lint and test commands per language in the YAML config file.[21] The auto-lint and auto-test options run the configured tools on every commit, and the loop terminates after a fixed number of retries (default three) to avoid runaway costs if the model cannot solve the failure.[24]

## Chat commands and shell integration

Aider provides a set of slash commands within the chat session for managing context, controlling behavior, and interacting with the file system and Git.[19] Key commands include:

| Command | Function |
|---|---|
| `/add <file>` | Adds a file to the session for editing |
| `/drop <file>` | Removes a file from the session |
| `/read <file>` | Adds a file as read-only context (not for editing) |
| `/clear` | Clears the chat history but keeps added files in context |
| `/reset` | Resets the chat history and drops all files |
| `/undo` | Reverts the last Aider commit with `git reset` |
| `/diff` | Shows a diff of the last Aider changes |
| `/git <args>` | Runs any Git command |
| `/run <cmd>` | Runs a shell command and adds output to the chat |
| `/voice` | Starts voice recording for speech-to-text input |
| `/web <url>` | Fetches a web page and adds its content to the chat |
| `/paste` | Pastes clipboard content (image or text) into the chat |
| `/lint` | Runs the configured linter and feeds errors back |
| `/test` | Runs the configured test command and feeds failures back |
| `/ask <question>` | Asks a question in ask mode (no file edits) |
| `/architect <request>` | Sends the request through architect/editor mode |
| `/code <request>` | Returns to code mode for a single request |
| `/context [request]` | Switches into context mode, in which Aider automatically identifies which files would need to be edited to fulfil the request and proposes adding them |
| `/model <name>` | Switches to a different model mid-session |
| `/editor-model <name>` | Sets or changes the editor model for architect mode |
| `/weak-model <name>` | Sets or changes the cheaper "weak" model used for chat-history summarisation and commit messages |
| `/reasoning-effort <low\|medium\|high>` | Adjusts the reasoning effort for models that expose the setting (notably the GPT-5 and o-series families) |
| `/think-tokens <budget>` | Sets the thinking-token budget for models such as Gemini 2.5 Pro and the Claude reasoning models |
| `/ok [extra instructions]` | Shortcut for "Ok, please go ahead and make those changes" so the user can accept a model's proposed edits without retyping the intent; optional arguments append additional steering |
| `/chat-mode <mode>` | Switches between code, ask, architect, and context modes without exiting the session |
| `/editor` | Opens an external editor for composing longer prompts |
| `/copy` | Copies the last AI response to the clipboard |
| `/ls` | Lists every file Aider tracks and whether it is in the chat, read-only, or excluded |
| `/tokens` | Reports current token usage in the session |
| `/help` | Lists available commands |
| `/exit` or `/quit` | Ends the session |

The `/run` command makes shell integration particularly useful. Developers can run build commands, data pipelines, or any other tooling from inside the chat and immediately have the output available as context for the next AI request.[19] Combined with the lint and test loops, this allows Aider to participate in build-fail-fix cycles without manual copy-pasting.

The `/web` command turns Aider into a reading agent. Given a URL, it scrapes the page, converts it to clean Markdown, and injects the result into the chat.[19] This is useful for pulling in API documentation, RFCs, or Stack Overflow answers without leaving the terminal. The `/paste` command does the equivalent for clipboard content, accepting either plain text or images (for multimodal models like Claude and GPT-4o that accept image input).[19]

Aider can also be driven non-interactively via the `--message` flag, which sends a single prompt and exits.[22] This enables scripted use cases: CI workflows that automatically attempt to fix failing tests, batch code generation pipelines, or pre-commit hooks that lint and correct code before a commit lands.

### Modes within a session

Aider supports four interactive modes that change how prompts are handled.[11] Code mode (the default) treats every prompt as an edit request. Ask mode (entered with `/ask` or `--ask`) tells the model to answer questions about the code without making changes; it is useful when reviewing an unfamiliar codebase.[11] Architect mode runs the dual-model workflow described above. Context mode (entered with `/context` or by running `/chat-mode context`) asks the model to identify which files would need to be edited to satisfy a request, without actually making the edit, and then proposes adding those files to the chat so the user can confirm before proceeding; this gives the model the ability to bootstrap a session in an unfamiliar repository without the user having to remember which files are relevant.[11] Users can switch modes mid-session, which lets them mix discussion and editing in the same conversation: ask a question, get an explanation, then say `/code now apply the fix` to make the change.[11]

## Watch files and IDE integration

The `--watch-files` mode, introduced in v0.67, turns Aider into a passive background agent that responds to editor activity.[20] With this mode enabled, Aider monitors every file in the repository for special comment markers. When a developer types a comment ending in `AI!` or containing `AI?` in any editor and saves the file, Aider sees the change and acts on it.[20]

The trigger comments come in several variants. A comment ending in `AI!` (such as `# rename this variable to count AI!`) tells Aider to take the action and modify the code. A comment ending in `AI?` tells Aider to answer the question without modifying anything. A plain `# AI: ...` is treated as an additional instruction added to the chat context for future turns.[20]

This workflow eliminates context switching between editor and terminal. Developers stay in [VS Code](/wiki/visual_studio_code), [Neovim](/wiki/neovim), [Cursor](/wiki/cursor), [Zed](/wiki/zed_editor), or any other editor.[20] Third-party VS Code extensions wrap this behavior with a graphical interface; the Apertia VSCode Aider extension syncs files automatically between Aider's session and VS Code's editor view and exposes basic controls in the command palette.[33] Other community projects target JetBrains IDEs through their built-in file watcher API.

## Conventions and project documentation

Aider supports a project-level conventions file that tells the model about repository-specific patterns, naming rules, and forbidden idioms.[23] The convention is usually called `CONVENTIONS.md` and is loaded into every session as read-only context.[23] Common contents include preferred libraries, framework conventions, expected test patterns, accessibility requirements, and code style guidelines that go beyond what a linter enforces.

A conventions file is added in one of three ways. The interactive command `/read CONVENTIONS.md` loads it for the current session only. The flag `aider --read CONVENTIONS.md` loads it on every startup. The YAML config `read: CONVENTIONS.md` makes the load automatic and project-wide.[23] The read-only flag is important: it ensures Aider does not propose edits to the conventions file itself and lets the system use prompt caching to amortize its cost across requests.[23]

The convention file pattern is similar to (and partly inspired) the [AGENTS.md](/wiki/agents_md) standard that emerged in late 2024 for cross-agent compatibility. AGENTS.md is a community-maintained schema that more recent tools like [Claude Code](/wiki/claude_code) and [Codex CLI](/wiki/codex_cli) also recognize, making it possible to write conventions once and have them apply to multiple agents.

## Is Aider free? Cost and pricing

Aider itself is free and open-source software under the Apache 2.0 license. There is no paid tier, no subscription, and no rate limiting imposed by Aider.[2] The cost of using Aider is entirely the cost of the underlying LLM API calls, following a pure bring-your-own-key (BYOK) model.[17]

Developers who use local models via Ollama pay nothing beyond their hardware and electricity costs, making Aider effectively free for those setups. For cloud APIs, costs vary significantly:

| Setup | Approximate monthly cost | Notes |
|---|---|---|
| Ollama local models | $0 | Requires capable hardware |
| DeepSeek V3 via API | ~$1-5 | Very low per-token pricing |
| Claude Sonnet (moderate use) | ~$10-30 | $3/$15 per million input/output tokens |
| GPT-4o (moderate use) | ~$10-25 | Competitive with Claude |
| GPT-5 or o3-Pro (heavy use) | $50-200+ | Frontier reasoning models cost more |

OpenRouter provides a single API key that routes to dozens of providers, including several models with free tier access. This gives developers a low-cost way to experiment before committing to a paid API.

### Prompt caching

The single biggest lever for reducing Aider's cost on long-running sessions is [prompt caching](/wiki/prompt_caching).[32] Anthropic introduced prompt caching for Claude in 2024, and Aider added support shortly afterward in v0.51.[32][8] The mechanism works by marking the system prompt, the repository map, and any read-only files as cacheable. On subsequent requests within a five-minute window (or longer with the one-hour cache option), those cached portions cost only 10 percent of the normal input price instead of the full price.[32] Cache writes cost 25 percent more than normal input on the first write but break even after just a few cache hits.[32]

The practical impact for a developer working a long session is dramatic. A typical session with a large repo map might send 10,000 cached input tokens per request. Without caching, that costs $0.030 per request at Claude Sonnet's $3 per million rate. With caching, those tokens cost $0.003 per request, a 90 percent reduction on what is usually the biggest component of an interactive session bill.[32] The OpenAI Responses API and Gemini equivalents have similar mechanics, although the exact discount rates vary by provider.

Other cost-saving practices include matching the model to the task (do not use o3-Pro to fix a typo), using `/clear` between unrelated tasks to keep history short, scoping the repo map to the relevant subdirectory, and falling back to DeepSeek or local models for routine work.[17] Following these practices typically keeps the monthly bill below $30 for a heavy individual user, compared with the $100+ that some other tools impose as a subscription baseline.[31]

## How does Aider compare to other AI coding tools?

The AI coding assistant space includes tools with distinct philosophies. The table below summarizes how Aider compares to the tools most often mentioned alongside it.

| Tool | Interface | Git integration | Model choice | Pricing | Open source |
|---|---|---|---|---|---|
| Aider | Terminal CLI | Native, every change is a commit | Any LLM via BYOK | Free (API costs only) | Yes (Apache 2.0) |
| [Claude Code](/wiki/claude_code) | Terminal CLI | Yes, via shell commands | Claude only | Pay per token (Anthropic) | No |
| [Cline](/wiki/cline) | VS Code extension | Via shell commands | BYOK (any provider) | Free (API costs only) | Yes |
| [Roo Code](/wiki/roo_code) | VS Code extension (fork of Cline) | Via shell commands | BYOK | Free | Yes |
| [Continue](/wiki/continue_dev) | VS Code and JetBrains extension | Limited | BYOK | Free | Yes |
| [Cursor (code editor)](/wiki/cursor) | Standalone IDE | Limited | Claude, GPT-4o, others | Free tier + $20/mo Pro | No |
| [GitHub Copilot](/wiki/github_copilot) | IDE extensions | No | GPT-4o, Claude | $10-19/mo | No |
| [Windsurf](/wiki/windsurf_editor) | Standalone IDE | Limited | Claude, GPT-4o | Free tier + $15/mo | No |
| [Codex CLI](/wiki/codex_cli) | Terminal CLI | Yes | OpenAI models | Pay per token | Yes |

Aider's distinguishing characteristics relative to these tools are its terminal-first design, its deep and automatic Git integration (every change becomes a commit, not just an optional one), and its model agnosticism.[37] Claude Code is the closest analog in the terminal space but is limited to Anthropic's models and does not make Git commits automatically. Codex CLI from OpenAI is similarly terminal-based but restricted to OpenAI models. [Cline](/wiki/cline), [Cursor](/wiki/cursor), and [Continue](/wiki/continue_dev) operate inside editors rather than the shell, which suits developers who prefer a GUI context. A 2026 benchmark found that Aider uses approximately 4.2x fewer tokens than Claude Code for equivalent tasks, which translates to a meaningful cost difference at scale.[31]

### vs Cursor

[Cursor](/wiki/cursor) is a fork of VS Code with deep AI integration baked into the editor. It is more polished for developers who want a fully graphical environment with inline suggestions and a chat panel docked beside the code.[38] Cursor charges a $20 per month Pro subscription that bundles API access, which is convenient but loses the model-choice flexibility Aider preserves. Aider's `--watch-files` mode partially bridges the gap by letting stock VS Code (or any editor) trigger Aider edits through saved comments.[20]

### vs Cline and Roo Code

[Cline](/wiki/cline) is a VS Code extension that takes the agentic approach further than Aider does. It runs autonomous loops where the agent can read files, run shell commands, browse the web, and execute multi-step plans with user approval gates.[37] [Roo Code](/wiki/roo_code), a community fork, adds additional modes. Both consume more tokens per task than Aider (the autonomous loop sends each tool result back to the model) and produce a less clean Git history.[37] Developers who want a hands-off agentic experience tend toward Cline; those who want surgical, reviewable edits tend toward Aider.

### vs Continue

[Continue](/wiki/continue_dev) is a VS Code and JetBrains extension oriented around inline autocomplete and chat. It supports BYOK and is open source, but its workflow is closer to GitHub Copilot than to Aider.[38] Continue's chat panel can run multi-file edits but lacks Aider's automatic Git integration, repo map, and lint/test feedback loops. The two tools are sometimes used together.

### vs Claude Code

[Claude Code](/wiki/claude_code) is Anthropic's official terminal CLI for [Claude](/wiki/claude), released in 2025.[37] It targets the same use cases as Aider but ships with Anthropic-specific defaults: Claude as the only model, an MCP-based plugin system, and tighter integration with [Claude.ai's](/wiki/claude_ai) subscriptions. Claude Code includes session memory through CLAUDE.md files (analogous to Aider's CONVENTIONS.md). Aider's advantages are model choice and lower per-task cost (roughly 4.2x cheaper).[31] Claude Code's advantages are polished Anthropic integration and more aggressive agentic behavior.

### vs GitHub Copilot

[GitHub Copilot](/wiki/github_copilot) runs as an extension in most major editors and provides inline autocomplete, chat, and (more recently) a multi-file agent mode for $10-19 per user per month.[38] It is the safe enterprise choice with corporate licensing. Aider does not compete on autocomplete; it targets a different workflow. Many developers use both: Copilot for line-level suggestions, Aider for whole-feature edits.

## Community

Aider has an active open-source community centered on GitHub and Discord. The GitHub repository (github.com/Aider-AI/aider) has roughly 46,500 stars and more than 4,600 forks as of mid-2026.[2] The Discord server has more than 10,000 members.[1]

The project releases frequently, with most versions shipping within days to a week of each other. The HISTORY.md file in the repository is detailed and comprehensive, documenting every change.[8] Gauthier maintains a blog at aider.chat/blog where he publishes benchmark results, feature announcements, and technical write-ups.[1]

Aider is often cited as the coding tool that eats its own dog food most visibly. Gauthier has reported that Aider writes a substantial percentage of its own code: approximately 88% of new code in recent releases was written by Aider itself, tracked by inspecting the `(aider)` commit attribution in the Git log.[17] The repository serves as a continuous demonstration of the tool's capabilities.

The community is informal but technically engaged. GitHub Discussions is the main place for feature requests and bug reports, with the Discord server handling more conversational support. Gauthier is active on both channels and on X (Twitter) as @paulgauthier.[44] A secondary ecosystem of plugins and wrappers has grown around Aider, including the Apertia VSCode Aider extension, RepoMapper (a standalone tool that ports Aider's repo map to other agents), and several community model preset files.[33][34]

## Use cases

Aider is used across a wide range of development scenarios.

In greenfield development, developers describe a feature or module in natural language and let Aider write the initial implementation. The Git history makes it easy to review what was produced and revert if needed.[9]

In refactoring, Aider can traverse large codebases (guided by the repo map) and apply systematic changes such as renaming conventions, adding type annotations, converting callback patterns to async/await, or migrating between library versions.[10]

In bug fixing, developers describe a bug or paste error output into the chat. Aider uses the lint and test loops to iterate toward a fix, with the test suite serving as the ground truth for when the fix is correct.[24]

In documentation and test generation, Aider can read source files and produce docstrings, README sections, or comprehensive test suites. The `/read` command keeps documentation-only files in context without marking them as editable.[19]

In autonomous batch processing, the `--message` and `--yes` flags allow Aider to run headlessly, processing a list of tasks from a script.[22] This pattern is used in CI pipelines that attempt automated fixes for common lint violations or test failures.

The watch-file mode enables a workflow where developers annotate code with `# AI:` comments inside any editor, commit or save, and Aider picks up the comments and acts on them.[20] This allows Aider to integrate into existing IDE workflows without requiring the developer to leave their editor.

For open-source maintainers, Aider is often used to triage incoming issues: paste the issue text and stack trace, let Aider draft a fix, run the test suite, and either accept or iterate. For solo developers and consultants, the atomic commit pattern and absence of subscription make it a clean productivity multiplier. For researchers and benchmark authors, Aider's open harness is the de facto reference implementation for evaluating coding LLMs, with Polyglot numbers widely cited across model comparisons from Anthropic, OpenAI, Google, and DeepSeek.[27]

## Limitations and concerns

Aider works with one Git repository at a time. There is no built-in support for cross-repository operations, though files from outside the repository can be imported as read-only context with `--read`.[17]

Performance degrades on very large repositories, particularly during the repo map computation. While the PageRank-based selection keeps the map token count bounded, parsing thousands of source files takes time, and the initial startup cost in a large monorepo can be noticeable.[10] Caching mitigates the cost on subsequent runs, but the first invocation in a fresh checkout can take tens of seconds.

Like all LLM-based coding tools, Aider is susceptible to model errors. The model may misunderstand a request, introduce subtle bugs, or apply an edit to the wrong location. The Git-native design mitigates this because every change is immediately reviewable and reversible, but it does not prevent incorrect changes from being made.[9] Developers should review AI commits before pushing, particularly in production codebases.

The voice feature requires an OpenAI API key for Whisper transcription even when using a different provider for code editing.[13] Developers using fully local or non-OpenAI setups who want voice input must use an external speech-to-text tool and type or pipe the result into Aider.

Aider does not have a native GUI. Developers who prefer visual interfaces will find the terminal workflow less approachable, though the watch-file feature partially bridges this gap by allowing any editor to send instructions to Aider passively.[20]

### Learning curve

The Aider workflow rewards investment. Developers used to autocomplete tools or IDE chat panels often find the first few hours of Aider disorienting because the interaction model is different: describe what you want, the model proposes a diff, Aider applies it, a Git commit appears. Mastery comes from learning which files to add, when to use ask versus code versus architect mode, and how to write conventions files that steer the model effectively.[17] Experienced users report productivity gains compound after the first week, but the onboarding cost is real.

### Token consumption with large repos

The repo map keeps the model's prompt manageable, but it is still possible to run up large bills on a sprawling codebase. A repository with millions of lines of code may need a 4K or 8K token map, and that map ships with every request unless caching is enabled.[10] The combination of architect mode and a large map on a frontier reasoning model can cost several dollars per turn in extreme cases. Practitioners manage this with aggressive `.aiderignore` rules, archived chat sessions, and explicit budget caps via `--max-cost`.[22]

### Privacy and data flow

When Aider is used with a commercial API, every prompt (including the relevant slice of the repository) is sent to that provider.[17] Organizations with strict source-code protection policies need to verify their chosen provider's terms of service and compliance posture (SOC 2, ISO 27001, etc). Local Ollama setups avoid this concern at the cost of weaker models. Some organizations run a self-hosted inference server and point Aider at it via the custom base URL flag.

## See also

- [Aider Polyglot](/wiki/aider_polyglot)
- [Claude Code](/wiki/claude_code)
- [Cline](/wiki/cline)
- [Continue](/wiki/continue_dev)
- [Cursor (code editor)](/wiki/cursor)
- [Codex CLI](/wiki/codex_cli)
- [Tree-sitter](/wiki/tree_sitter)
- [GitHub Copilot](/wiki/github_copilot)
- [Large language model](/wiki/large_language_model)
- [Paul Gauthier](/wiki/paul_gauthier)
- [Inktomi](/wiki/inktomi)
- [Prompt caching](/wiki/prompt_caching)
- [Agentic coding](/wiki/agentic_coding)
- [Roo Code](/wiki/roo_code)
- [DeepSeek R1](/wiki/deepseek_r1)
- [AGENTS.md](/wiki/agents_md)
- [Ollama](/wiki/ollama)
- [OpenRouter](/wiki/openrouter)
- [LM Studio](/wiki/lm_studio)

## References

1. Gauthier, Paul. "Aider AI Pair Programming in Your Terminal." aider.chat. https://aider.chat/
2. Aider-AI/aider GitHub repository. https://github.com/Aider-AI/aider
3. Gauthier, Paul. "Improving GPT-4's codebase understanding with ctags." aider.chat, May 2023. https://aider.chat/2023/05/25/ctags.html
4. Gauthier, Paul. "Building a better repository map with tree sitter." aider.chat, October 2023. https://aider.chat/2023/10/22/repomap.html
5. Gauthier, Paul. "Unified diffs make GPT-4 Turbo 3X less lazy." aider.chat, December 2023. https://aider.chat/docs/unified-diffs.html
6. Gauthier, Paul. "Separating code reasoning and editing." aider.chat, September 2024. https://aider.chat/2024/09/26/architect.html
7. Aider LLM Leaderboards. aider.chat. https://aider.chat/docs/leaderboards/
8. Aider Release History. aider.chat. https://aider.chat/HISTORY.html
9. Aider Git integration documentation. aider.chat. https://aider.chat/docs/git.html
10. Aider Repository Map documentation. aider.chat. https://aider.chat/docs/repomap.html
11. Aider Chat Modes documentation. aider.chat. https://aider.chat/docs/usage/modes.html
12. Aider Edit Formats documentation. aider.chat. https://aider.chat/docs/more/edit-formats.html
13. Aider Voice-to-code documentation. aider.chat. https://aider.chat/docs/usage/voice.html
14. Aider Polyglot Benchmark. GitHub. https://github.com/Aider-AI/polyglot-benchmark
15. "R1+Sonnet set SOTA on aider's polyglot benchmark." aider.chat, January 2025. https://aider.chat/2025/01/24/r1-sonnet.html
16. Paul Gauthier LinkedIn profile. https://www.linkedin.com/in/paulgauthier
17. Aider FAQ. aider.chat. https://aider.chat/docs/faq.html
18. Aider Installation documentation. aider.chat. https://aider.chat/docs/install.html
19. Aider In-chat commands. aider.chat. https://aider.chat/docs/usage/commands.html
20. Aider in your IDE (watch files). aider.chat. https://aider.chat/docs/usage/watch.html
21. Aider YAML config file. aider.chat. https://aider.chat/docs/config/aider_conf.html
22. Aider Options reference. aider.chat. https://aider.chat/docs/config/options.html
23. Aider Specifying coding conventions. aider.chat. https://aider.chat/docs/usage/conventions.html
24. Aider Linting and testing. aider.chat. https://aider.chat/docs/usage/lint-test.html
25. Aider DeepSeek documentation. aider.chat. https://aider.chat/docs/llms/deepseek.html
26. Aider Advanced model settings. aider.chat. https://aider.chat/docs/config/adv-model-settings.html
27. Llm-stats.com Aider-Polyglot benchmark leaderboard. https://llm-stats.com/benchmarks/aider-polyglot
28. Refact.ai blog. "Refact.ai Agent + Claude 3.7 Sonnet tops Aider's polyglot benchmark." 2025. https://refact.ai/blog/2025/refact-ai-agent-claude-3-7-sonnet-ranked-1-aider-polyglot/
29. Wikipedia. "Inktomi." https://en.wikipedia.org/wiki/Inktomi
30. Crunchbase, "Paul Gauthier." https://www.crunchbase.com/person/paul-gauthier
31. Morph LLM. "Aider Uses 4.2x Fewer Tokens Than Claude Code (2026)." https://www.morphllm.com/comparisons/morph-vs-aider-diff
32. Anthropic. "Prompt caching with Claude." https://www.anthropic.com/news/prompt-caching
33. Aider VSCode extension. Visual Studio Marketplace. https://marketplace.visualstudio.com/items?itemName=Apertia.vscode-aider
34. RepoMapper GitHub repository. https://github.com/pdavis68/RepoMapper
35. DeepWiki. "Repository Mapping System." https://deepwiki.com/Aider-AI/aider/4.1-repository-mapping-system
36. Arxiv. "Diff-XYZ: A Benchmark for Evaluating Diff Understanding." 2025. https://arxiv.org/html/2510.12487v1
37. AImultiple. "Agentic CLI Tools Compared: Claude Code vs Cline vs Aider." https://aimultiple.com/agentic-cli
38. DEV Community. "2025s Best AI Coding Tools." https://dev.to/stevengonsalvez/2025s-best-ai-coding-tools-real-cost-geeky-value-honest-comparison-4d63
39. DeployHQ. "Aider Guide 2026." https://www.deployhq.com/guides/aider
40. Hacker News. Discussion of Aider tooling. https://news.ycombinator.com/item?id=41980045
41. Aider GitHub Releases. https://github.com/Aider-AI/aider/releases
42. Aider GitHub Copilot integration documentation. aider.chat. https://aider.chat/docs/llms/github.html
43. Gauthier, Paul. X (Twitter) announcement of Aider v0.85.0. June 2025. https://x.com/paulgauthier/status/1938746648932557278
44. Gauthier, Paul. X (Twitter) announcement of Aider v0.86.0. August 2025. https://x.com/paulgauthier/status/1954237677265617297
45. Aider v0.86.0 GitHub release notes. https://github.com/Aider-AI/aider/releases/tag/v0.86.0
46. Aider HISTORY.md on the main branch. https://github.com/Aider-AI/aider/blob/main/HISTORY.md
47. DeepWiki. "Release Notes and History." https://deepwiki.com/Aider-AI/aider/10.3-release-notes-and-history