Aider

Overview

Aider is an open-source AI pair programming tool that lives in your terminal. It connects large language models to your local git repository: you chat in natural language, Aider edits the right files, and it commits each change with a sensible message so you can /undo, diff, or branch like any other git workflow.

Created by Paul Gauthier and maintained under the Aider-AI org (Apache 2.0). Product home: aider.chat. Source: github.com/Aider-AI/aider (tens of thousands of stars; PyPI package aider-chat, latest stable line around v0.86.x as of early 2026). Primary job: turn a skilled developer’s requests into multi-file code changes with full control over model choice, context, and cost—without switching to a proprietary IDE.

Aider is free software. There is no Aider subscription. You bring API keys (or run local models). That “BYOK” model is the whole pricing story—and the main reason power users keep it beside Cursor or Claude Code.

Key features

• Terminal-native pair programming — Chat-driven edits in any git repo. Default “code” mode applies changes; you stay in a turn-based loop rather than an unsupervised agent swarm.
• Repository map — Tree-sitter–based map of classes, functions, and signatures. A graph ranker packs the most relevant symbols into a small token budget (default ~1k map tokens, expandable) so large codebases stay usable without dumping every file into context.
• Git-first workflow — Auto-commits after edits with Conventional Commits–style messages; commits dirty files first so your work stays separate; /undo, /diff, /commit, /git; optional “(aider)” attribution on author/committer; --no-auto-commits / --no-git if needed.
• Chat modes — code (edit), ask (discuss only), architect (planner model + editor model), help (Aider itself). Sticky modes via /chat-mode or one-shot /ask, /architect, etc. Ask→code is the recommended planning workflow (“go ahead” after you agree on a plan).
• Model-agnostic LLMs — OpenAI, Anthropic, Gemini, DeepSeek, xAI, Groq, Cohere, Azure, Vertex, Bedrock, OpenRouter, GitHub Copilot endpoints, LM Studio, Ollama, and generic OpenAI-compatible servers. Mid-session /model switching; model aliases and YAML/.env config.
• Edit formats — Diff / diff-fenced / whole-file / udiff / architect editor formats chosen per model so weaker models still apply patches reliably when capable ones use search-replace blocks.
• IDE watch mode — Run Aider alongside Vim, VS Code, JetBrains, etc.: add an “AI comment” in the editor and Aider picks it up and implements the change without a dedicated plugin.
• Lint, test, and shell — Auto-lint/test after edits and iterate on failures; /run to capture command output into chat (e.g. /run pytest or /run git diff HEAD~3).
• Images, URLs, voice — Attach screenshots/docs pages; optional voice-to-code; experimental browser UI; copy/paste bridge for web-only LLM UIs when you lack an API key.
• Prompt caching & cost controls — Caching where providers support it; /tokens for live usage; conventions files for project style; scripting via CLI or Python for CI/automation.
• Public LLM leaderboards — The Aider polyglot benchmark (225 Exercism-style tasks across C++, Go, Java, JS, Python, Rust) is a widely cited real-edit benchmark, not just autocomplete accuracy. Self-stats: Aider historically writes a large share of its own codebase (often ~70% of new lines per release via git blame).
• 100+ languages — Python, JS/TS, Rust, Go, C/C++, Ruby, PHP, HTML/CSS, and many more via tree-sitter language packs.

Pricing

Aider the software costs $0. License is Apache 2.0. Install from PyPI (aider-chat / aider-install), source, or official install scripts. There is no paid “Aider Pro” seat as of this writing.

You pay the LLM provider (or your GPU electricity for local models). Typical patterns:

Path	What you pay	Notes
Aider CLI itself	$0	Open source; self-hosted on your machine
Cloud APIs (Claude, GPT, Gemini, etc.)	Provider $/1M tokens	Heavy use often tens of dollars/month; Morph-style writeups cite ~$60/mo heavy API vs higher flat seats elsewhere
DeepSeek & other cheap APIs	Low cents per task	Strong price/quality on Aider’s leaderboard for chat/reasoner variants
OpenRouter free tier / Gemini free experiments	$0 with limits	Rate-limited; fine for experiments
Ollama / LM Studio local	Hardware only	Privacy; weaker models often fail structured edits

Practical cost tips from docs and community: add only files you will edit (do not dump the whole monorepo into chat); rely on the repo map; use /drop; enable prompt caching for Anthropic-class models; use architect mode only when the quality gain is worth the double request; prefer DeepSeek or flash-class models for small chores and flagship models for hard refactors. OpenReplay-style guides report roughly $0.01–$0.10 per small feature on mid-tier cloud models when context is tight—your mileage varies with model and chat length.

Limits & gotchas

• Less agentic than Claude Code / full IDE agents — Aider is pair programming: you choose files, approve the loop, and drive git. It is not a multi-day autonomous worker that explores, spawns subagents, and owns the shell by default. Many users call that a feature (safer on real codebases); juniors may prefer more autonomous tools.
• Context discipline is manual — Adding “all files” usually hurts quality and cost. FAQ explicitly warns against it. Monorepos need --subtree-only, .aiderignore, or directory-focused sessions.
• One git repo at a time — Multi-repo work requires /read of foreign files, exported maps, or docs—not a first-class multi-root project model.
• Model quality gates edits — Weak models may print code but fail Aider’s edit formats (no clean commit). Below roughly GPT-3.5-class skill, expect pain; check the official leaderboard before trusting a new local GGUF.
• Architect mode doubles calls — Great for o1-style planners + a strong editor model; slower and pricier. Not always better than ask→code with one strong model.
• Large-repo latency — Works anywhere git works, but map build and ranking are not optimized for huge monorepos without ignore rules.
• Terminal UX / no first-class GUI IDE — Browser UI is experimental. No Copilot-style ghost text. Diff review is CLI/git-centric (some teams prefer IDE visual diffs in Cursor).
• Release cadence — After a rapid 2024–2025 cadence, stable line around v0.86.x (PyPI notes early 2026 releases) is more maintenance-oriented; community forks (e.g. aider-ce) exist for people wanting faster agentic experiments.
• Pre-commit hooks — By default commits use --no-verify unless you enable --git-commit-verify.
• Privacy — Code leaves your machine when you use cloud APIs. Local Ollama/compat endpoints keep tokens home; still review provider data policies for enterprise code.

Community sentiment

On Reddit’s r/ChatGPTCoding and Hacker News, Aider has a durable reputation as the precision, git-native, model-free choice. Long threads comparing it to Claude Code (mid–late 2025) often say Aider is faster, less likely to thrash a mature codebase, and better when the human already knows the stack—while Claude Code wins on raw tool use, scaffolding, and approachability for less experienced devs. “Why aren’t you using Aider?” posts praise Gemini/DeepSeek pairings and cost transparency; skeptics cite the learning curve and lack of flashy agent autonomy.

HN discussions highlight turn-taking: every change is a commit, /undo is a hard reset of the last AI commit, and ask-mode planning then “make it so” in code mode feels closer to real pair programming than fire-and-forget agents. Author threads about Aider writing large fractions of its own code reinforce credibility with OSS builders. Discord (linked from docs) is active for model tips and config.

Versus Cursor: Aider wins on model freedom, cost control, and SSH/remote terminal workflows; Cursor wins on GUI, Tab autocomplete, and zero-friction VS Code habits. Versus Copilot: Aider is multi-file chat + git agent, not inline completion. Benchmark culture around the polyglot leaderboard means model vendors and reviewers still cite Aider scores in 2025–2026 model launches.

Who should use it

• CLI- and git-centric developers (Vim, Emacs, plain VS Code, remote SSH) who want AI without a forked IDE.
• Cost-sensitive or multi-model power users who switch between DeepSeek, Sonnet, GPT, and local models mid-week.
• Teams that need auditable AI diffs — every change is a commit with attribution options for code review.
• Engineers doing surgical refactors on existing repos more than greenfield “vibe apps.”
• People scripting AI edits in CI or batch jobs via Aider’s CLI/Python scripting.
• Not ideal for non-developers, pure “chat builds my whole SaaS” beginners, or anyone who refuses to manage files/context and only wants a GUI agent.

Alternatives

• Cursor — AI-native VS Code fork; best when you want GUI + Tab + Composer agents in one editor seat.
• Claude Code — Anthropic’s agentic terminal tool; stronger autonomy and tool use, Anthropic-centric plans/limits.
• GitHub Copilot — Inline completions and chat inside mainstream IDEs; simpler enterprise procurement, less BYOK freedom.
• Cline — VS Code agent extension; more autonomous browser/tool loops, different cost profile.
• Roo Code — Open agentic coding in the editor; alternative if you want OSS + IDE rather than pure terminal.
• Windsurf — IDE-centric agentic coding with a polished product UI.
• Ollama — Local model runtime often paired with Aider via ollama/… models for offline work.

See also comparisons: Cursor vs Aider, Aider vs Claude Code, Aider vs Cline.

Verdict

Aider remains one of the best open-source, git-native AI pair programmers in 2026 if you value control: choose any model, keep commits clean, map large repos without stuffing context, and pay only for tokens you actually use. It is not the flashiest agent, and it will not replace judgment on a brownfield codebase. For developers already fluent in terminal + git who are tired of seat fees and opaque agents, it is still a default tool—not a nostalgia project.

Bottom line: install it free, wire a strong model (or a cheap DeepSeek for volume), add only the files you mean to change, and use ask→code (or architect when needed). Keep Cursor or Claude Code when you want GUI comfort or maximal autonomy; keep Aider when you want the AI to pair, not pilot.