Aider
Last reviewed
May 13, 2026
Sources
40 citations
Review status
Source-backed
Revision
v2 ยท 8,197 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
May 13, 2026
Sources
40 citations
Review status
Source-backed
Revision
v2 ยท 8,197 words
Add missing citations, update stale details, or suggest a clearer explanation.
Aider is an open-source AI pair programming tool that runs in the terminal and integrates directly with Git. Created by Paul Gauthier and first released in April 2023, it lets developers converse with large language models (LLMs) to write, edit, and refactor code across any codebase. 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. As of mid-2025 the project has accumulated more than 44,000 GitHub stars, over 6.8 million pip installs, and its users collectively process roughly 15 billion tokens per week.
Aider sits in a category of agentic coding tools that emerged after the release of GPT-4 in early 2023. It is most often compared to Claude Code, Cline, Cursor, and GitHub Copilot, but its design priorities are distinctly different: terminal-first, model-agnostic, Git-native, and explicitly bring-your-own-key. Its Aider Polyglot benchmark has become one of the most-cited evaluations of LLM coding ability.
Aider is a command-line interface program written in Python that exposes a chat-style prompt for editing source code with an LLM. 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. 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. 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. 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.
Paul Gauthier is a veteran engineer with roots in the early commercial internet. He co-founded Inktomi in January 1996 with University of California, Berkeley professor Eric Brewer, serving as the company's founding chief technology officer. 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. Inktomi was acquired by Yahoo in 2003 for roughly $235 million. 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.
Gauthier started building Aider in April 2023, shortly after the widespread release of GPT-4 made it plausible that an LLM could reliably produce working code patches. The earliest versions used ctags (and later 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. 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.
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. Voice-to-code was added in v0.12. The architect/editor dual-model workflow arrived in v0.58, and IDE watch-file integration came in v0.67. The project publishes a detailed HISTORY.md tracking every release.
In May 2023 Gauthier wrote about using ctags to improve GPT-4's codebase understanding. By October 2023 the approach had been redesigned around Tree-sitter with a PageRank-based relevance graph. In December 2023 a blog post showed that unified diffs reduced GPT-4 Turbo's lazy coding behavior by about 3x. Through 2024 and into 2025, Aider consistently appeared near the top of coding benchmarks, and in January 2025 the combination of DeepSeek R1 as architect and Claude 3.5 Sonnet as editor set a state-of-the-art score on the Aider Polyglot benchmark.
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 | 2025 | o3-pro, Responses API, and Gemini 2.5 Pro thinking tokens |
| v0.86 | August 2025 | Full GPT-5 family support across providers |
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.
Aider is distributed as a Python package on PyPI under the name aider-chat and a thin installer wrapper aider-install. 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, the fast Rust-based Python package manager. 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. A single uv tool upgrade aider-chat command keeps it current. The older alternative is 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.
Aider runs on macOS, Linux, and Windows, with Python 3.10 or newer as the only hard requirement. The voice feature additionally needs the portaudio system library, which is installed via Homebrew on macOS or the appropriate package manager on Linux. 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. The session starts in code mode by default, ready to accept instructions.
At first launch, the user describes a feature, asks a question, or adds files for editing with /add. 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.
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. The user types natural-language instructions and Aider responds by editing files and committing the changes.
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. 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. If the model returns text that does not parse cleanly as a valid edit, Aider will try to recover by re-prompting.
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. Commit messages follow the Conventional Commits specification by default. Aider appends (aider) to the Git author and committer fields so the provenance of AI-generated commits is visible in the log. 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.
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. A developer can type a # AI: comment in VS 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.
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. Aider selects the optimal format automatically based on which model is in use, but developers can override with the --edit-format flag.
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. 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.
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. 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. 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.
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. 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. A December 2023 benchmark showed the udiff format reduced lazy responses by approximately 3x for that model family.
This is a variant of the diff format in which the file path appears inside the fenced code block rather than before it. 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.
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. The new udiff format raised the same model to 61 percent on the same benchmark, a roughly 3x improvement. The original GPT-4 (June 2023 snapshot) jumped from 26 percent baseline to 59 percent with udiff for similar reasons.
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. 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.
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.
Aider solves this with an automatically generated, dynamically sized repository map. 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. 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. The result is a set of tags: each tag records a symbol name, its kind (definition or reference), its file, and its line number.
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). 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. The graph is then scored with a PageRank-like algorithm (using NetworkX's implementation) with the chat files as the personalization set. 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). 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. When many files are already open, the map shrinks to make room.
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.
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.
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. The .aiderignore file uses .gitignore syntax to exclude specific paths or globs from the repo map. Both reduce parsing time, repo map size, and token cost, and they reduce the chance that the model gets distracted by unrelated code.
Architect mode is a dual-model workflow introduced in Aider v0.58 (September 2024). 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.
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. 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. The architect model defaults to the main configured model; the editor model defaults to a separate, often cheaper, model configured via --editor-model. 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.
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. 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%.
As of early 2025, the combination of 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.
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. Developers can pick the architect/editor combination that matches their accuracy and budget targets independently.
Aider includes a built-in voice-to-code feature accessible through the /voice command during any chat session. 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 API and injects the transcribed text into the chat session exactly as if the user had typed it, after which normal code editing proceeds.
The feature requires an active internet connection and an OpenAI API key for the Whisper transcription, even when using a different provider for the main LLM interaction. It also requires the portaudio system library for audio recording. On macOS, this can be installed with Homebrew; on Linux, with the system package manager.
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.
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. 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 | Top overall performers; Claude Sonnet family is frequently the default recommendation |
| OpenAI | GPT-4o, GPT-5, o1, o3, o3-mini, o3-pro | GPT-5 leads the Aider Polyglot leaderboard as of 2025; o-series excel in architect mode |
| Gemini 2.5 Pro, Gemini 2.0 Flash | Gemini 2.5 Pro is near the top of the leaderboard | |
| DeepSeek | DeepSeek R1, DeepSeek V3/V3.2, DeepSeek Chat | Highly competitive at significantly lower cost |
| 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 |
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.
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. For unknown models, Aider falls back to sensible defaults and allows manual override.
Ollama is the most common path for running Aider against fully local models, including Llama 3, Qwen 2.5 Coder, DeepSeek Coder, and various distilled variants. Performance with local models depends entirely on the model and the user's hardware. 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 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.
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). Users override defaults locally with --model-settings-file and use short aliases like sonnet, 4o, r1, and gpt5 to avoid long names.
Aider maintains its own coding benchmark, the Aider Polyglot, to evaluate LLM performance on code editing tasks representative of real-world pair programming. The benchmark consists of 225 challenging exercises drawn from the Exercism platform, spanning six programming languages: C++, Go, Java, JavaScript, Python, and Rust. 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. 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.
The benchmark is run through Aider itself, making the harness directly representative of how the models perform in actual use. Results are published on the Aider leaderboard at aider.chat/docs/leaderboards/.
As of mid-2025, the leaderboard is led by GPT-5 at 88.0 percent, followed by GPT-5 Medium at 86.7 percent, o3-Pro at 84.9 percent, and Gemini 2.5 Pro Preview at 83.1 percent. 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.
| 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% | varies | 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. These additional columns make the leaderboard useful for diagnosing why a particular model underperformed rather than just ranking the totals.
Aider also maintains a separate "code editing" leaderboard at aider.chat/docs/leaderboards/edit.html. 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. 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.
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. This loop continues until the linter passes or Aider exhausts a configured number of retries.
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. Test failures are fed back to the model as context so it can diagnose and fix the broken code without developer intervention. 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.
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.
Users typically set the lint and test commands per language in the YAML config file. 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.
Aider provides a set of slash commands within the chat session for managing context, controlling behavior, and interacting with the file system and Git. 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 |
/model <name> | Switches to a different model mid-session |
/editor-model <name> | Sets or changes the editor model for architect mode |
/copy | Copies the last AI response to the clipboard |
/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. 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. 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).
Aider can also be driven non-interactively via the --message flag, which sends a single prompt and exits. 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.
Aider supports three modes that change how prompts are handled. 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. Architect mode runs the dual-model workflow described above. 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.
The --watch-files mode, introduced in v0.67, turns Aider into a passive background agent that responds to editor activity. 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.
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.
This workflow eliminates context switching between editor and terminal. Developers stay in VS Code, Neovim, Cursor, Zed, or any other editor. 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. Other community projects target JetBrains IDEs through their built-in file watcher API.
Aider supports a project-level conventions file that tells the model about repository-specific patterns, naming rules, and forbidden idioms. The convention is usually called CONVENTIONS.md and is loaded into every session as read-only context. 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. 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.
The convention file pattern is similar to (and partly inspired) the 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 and Codex CLI also recognize, making it possible to write conventions once and have them apply to multiple agents.
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. The cost of using Aider is entirely the cost of the underlying LLM API calls, following a pure bring-your-own-key (BYOK) model.
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.
The single biggest lever for reducing Aider's cost on long-running sessions is prompt caching. Anthropic introduced prompt caching for Claude in 2024, and Aider added support shortly afterward in v0.51. 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. Cache writes cost 25 percent more than normal input on the first write but break even after just a few cache hits.
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. 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. 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.
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 | Terminal CLI | Yes, via shell commands | Claude only | Pay per token (Anthropic) | No |
| Cline | VS Code extension | Via shell commands | BYOK (any provider) | Free (API costs only) | Yes |
| Roo Code | VS Code extension (fork of Cline) | Via shell commands | BYOK | Free | Yes |
| Continue | VS Code and JetBrains extension | Limited | BYOK | Free | Yes |
| Cursor (code editor) | Standalone IDE | Limited | Claude, GPT-4o, others | Free tier + $20/mo Pro | No |
| GitHub Copilot | IDE extensions | No | GPT-4o, Claude | $10-19/mo | No |
| Windsurf | Standalone IDE | Limited | Claude, GPT-4o | Free tier + $15/mo | No |
| 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. 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, Cursor, and Continue 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.
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. 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.
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. 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. Developers who want a hands-off agentic experience tend toward Cline; those who want surgical, reviewable edits tend toward Aider.
Continue 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. 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.
Claude Code is Anthropic's official terminal CLI for Claude, released in 2025. 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 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). Claude Code's advantages are polished Anthropic integration and more aggressive agentic behavior.
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. 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.
Aider has an active open-source community centered on GitHub and Discord. The GitHub repository (github.com/Aider-AI/aider) has over 44,000 stars and more than 4,400 forks as of mid-2025. The Discord server has more than 10,000 members.
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. Gauthier maintains a blog at aider.chat/blog where he publishes benchmark results, feature announcements, and technical write-ups.
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. 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. 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.
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.
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.
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.
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.
In autonomous batch processing, the --message and --yes flags allow Aider to run headlessly, processing a list of tasks from a script. 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. 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.
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.
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. 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. 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. 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.
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. Experienced users report productivity gains compound after the first week, but the onboarding cost is real.
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. 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.
When Aider is used with a commercial API, every prompt (including the relevant slice of the repository) is sent to that provider. 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.