Aider in Practice: Terminal-Native AI Pair Programming, Done Right

Aider does one thing the rest of the 2026 coding-agent field gave up on: every change it makes is a real git diff you can read, revert, and rebase. No sandbox black box, no PR that appears fully formed, no sub-agent you have to trust.

You drive the loop, and the working tree only ever moves in increments you approved.

That narrowness is now a deliberate choice. The current release, aider-chat v0.86.2, shipped on 2026-02-12 and carries no sub-agents, no MCP, no image input. The field around it raced toward richer harnesses.

Aider stayed a terminal AI pair programming tool that writes reviewable diffs with any model, and independent reviewers in 2026 still call it the gold standard for exactly that.

This guide is for the practitioner who wants to use it well: the repo map, the git loop, architect mode, and the config that makes it cheap.

TL;DR

Aider is a terminal-native AI pair programmer that edits your real files as git commits and works with any model through LiteLLM. Its strengths are reviewable diffs, instant /undo, and model-agnosticism. Its non-features as of June 2026 are sub-agents, MCP, and multimodal input. Power users win by wiring --auto-lint and --auto-test into the loop, routing cheap work to a --weak-model, scoping large repos with --subtree-only, and using architect mode to split planning from editing.

Key takeaways

• The current release is v0.86.2 (2026-02-12); main has moved ahead with a git rework and newer models but no numbered release yet, per the changelog.
• The repo map uses tree-sitter plus personalized PageRank to send symbols, not whole files, on every turn.
• --auto-lint plus --auto-test is the single biggest quality-per-dollar lever: failures get fed back to the model and the commit is held until they pass.
• --weak-model (Haiku 4.5) for commit messages and ranking is the cheapest cost cut you can make.
• /undo rewinds both the file and the commit. No other major CLI tool does this cleanly.

What is Aider, and where does it fit in 2026?

Aider is an open-source, terminal-native AI pair programming tool maintained by Paul Gauthier under the Aider-AI GitHub org, Apache 2.0 licensed, with roughly 46k stars as of mid-2026. The pitch has been the same since 2024 and it still holds: it writes real diffs into your working tree, commits them with attributable co-author metadata, and produces changes that survive code review.

What changed is the competition. Claude Code, OpenAI Codex CLI, and Windsurf all shipped first-party sub-agents in early 2026. Aider didn't, and it won't. It occupies one narrow position: purely terminal, purely diff-emitting, explicitly single-loop.

That makes it an explicit trade now. You give up agentic surface area and get back reviewability, full model choice, and zero SaaS lock-in.

Installation and pointing Aider at any model

The recommended install on Linux and macOS in mid-2026 is the uv-backed helper, which isolates Aider from your system Python via a managed Python 3.12, per the install docs:

python -m pip install aider-install
aider-install

Fallbacks are pipx install aider-chat, brew install aider, or the paulgauthier/aider Docker image. Verify with aider --version; a fresh install gives v0.86.2 as of 2026-06-17.

Aider is model-agnostic through LiteLLM. The LLMs doc lists 16 providers including OpenAI, Anthropic, Google, xAI, DeepSeek, Ollama, OpenRouter, Azure, Bedrock, and Vertex. You point it with a flag or a config key, and auth is plain env vars (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, and so on).

What's current (as of June 2026)

One honesty note on versions. Anthropic's most recent first-party confirmed model is Claude Opus 4.5. A newer "Opus 4.8" has been reported by Marktechpost (2026-05-28) but I could not confirm it against an Anthropic page, so treat that name as derivative until first-party docs catch up.

The newest Anthropic and Gemini 3 families are usable from Aider's main branch but are not all in the v0.86.2 wheel yet.

How does the Aider repo map work?

The repo map is the feature that makes Aider scale past toy repos, and understanding it changes how you use the tool. Instead of stuffing files into context, Aider sends a compact map of your codebase on every request.

The algorithm, per the repomap docs, is built with tree-sitter (130+ languages via tree-sitter-language-pack since v0.77.0; ctags is gone):

1. Extract top-level symbols (functions, classes, methods) from each file.
2. Build a graph where files are nodes and symbol references are edges.
3. Run personalized PageRank biased toward symbols already in the chat.
4. Binary-search-pack the top symbols into the --map-tokens budget (default 1024).

The map rebuilds per turn and per session. There's no cross-session cache, so every aider invocation starts cold. The practical consequence: after a big rename or import change, the ranking can point at deleted symbols and edit quality silently drops. Recovery is /map-refresh in chat, or just restart.

For large monorepos, raise --map-tokens to 2048-8192, and scope aggressively with --subtree-only. Practitioners report --subtree-only gives roughly 2-4x faster first turns and ~30% lower token cost because the map is denser within the scope you care about. Aider's docs don't publish a benchmark for that figure, so treat it as field-reported.

The git loop: where Aider earns its place

By default Aider makes one commit per logical change, prefixes the message with aider:, and adds a Co-Authored-By: trailer, per the git docs. The controls that matter:

A senior-engineer workflow starts cautious with --no-auto-commits, approves changes turn by turn, then runs /commit with a curated message. The in-chat commands are the workhorses:

• /undo rewinds the last edit and its commit, putting the tree byte-for-byte back. There's no clean equivalent in Cursor, Claude Code, or Codex CLI; the nearest is git reset HEAD~1 plus manual fixes.
• /clear drops chat history but keeps the file set, cheaper than a full reset.
• /diff shows the cumulative session diff.

/undo is the most underrated power-user feature here. It means you can attempt a risky refactor knowing the cost of being wrong is one keystroke.

Wire the feedback loop, or it ships broken code

This is the part people skip and regret. Aider does not run your diff before committing unless you tell it to. With the loop wired, per the lint-test docs, Aider runs your lint and test commands after each edit, feeds any failures back to the model, and holds the commit until they pass:

auto-lint: true
lint-cmd: "ruff check --fix"
auto-test: true
test-cmd: "pytest -q"

A session running ruff --fix and pytest -q in the loop catches most "model wrote broken Python" mistakes before you ever read the diff. The architecture-level errors still need your eyes. But the syntax-and-import class of failure stops being your problem.

Architect mode and the weak-model pattern

Aider documents four chat modes: code (default), architect, ask (read-only Q&A), and help. Architect mode is the one power users reach for on multi-file changes.

In architect mode, your --model is the planner and your --editor-model is the editor. The planner reads the map and conversation, decides what to change, and emits a spec.

The editor turns that spec into search/replace diffs and applies them. The planner does the expensive thinking once per turn; the editor does cheap deterministic work. --auto-accept-architect (default true since v0.77.0) accepts the plan automatically, but the diff still needs your approval.

Pair that with --weak-model, the most under-used cost lever in Aider. It automatically routes three classes of work off your expensive model: commit messages, repo-map ranking, and read-only file summaries. Opus is absurd overkill for a commit message; Haiku 4.5 handles it fine.

Here's the flagship Python config that ties it together:

# .aider.conf.yml — committed, safe for the whole team
model: anthropic/claude-opus-4-5
weak-model: anthropic/claude-haiku-4-5
editor-model: anthropic/claude-sonnet-4-5
architect: true
edit-format: architect
auto-commits: true
auto-lint: true
lint-cmd: "ruff check --fix"
auto-test: true
test-cmd: "pytest -q"
map-tokens: 2048
cache-prompts: true
read:
  - CONVENTIONS.md

Opus plans, Sonnet edits, Haiku writes commits, and the lint/test loop guards every commit. Note that Aider does not auto-load CONVENTIONS.md; you load it explicitly with read: or /read, which puts your house style in the cacheable read-only slot, per the conventions docs.

Config precedence runs CLI flag, then repo .aider.conf.yml, then ~/.aider.conf.yml, then defaults, per the config docs. So commit only team-wide settings to the repo file and keep personal overrides in your home config.

Where Aider loses, honestly

Aider's own polyglot leaderboard (225 Exercism exercises across six languages) is the right benchmark for "can this model produce a working diff in a real repo," and it's dominated by the same frontier models above. But the tool itself has hard limits worth naming.

Reach for something else when the job is a long-running autonomous task (Claude Code, Codex CLI), a screenshot-driven UI build (Cursor, Codex CLI), or an MCP-heavy stack wired to Postgres, Linear, or Sentry. Aider won't connect to any of those.

What this means for you

If your daily work is "change this function, review the diff, commit," Aider is faster and cleaner than anything with a heavier harness. Set it up once and the rest is muscle memory.

Commit a .aider.conf.yml with weak-model, auto-lint, and auto-test. Load your CONVENTIONS.md with read:. Start risky sessions with --no-auto-commits, lean on /undo, and scope big repos with --subtree-only. Use architect mode when a change spans five or more files.

And watch the PyPI page: main is moving fast with a git rework and newer models, so the next numbered release will shift several flags above. Re-check provider pricing pages before pinning any cost number in a production decision.

Sources

• aider-chat on PyPI
• Aider-AI/aider on GitHub
• Aider repo map docs
• Aider chat modes
• Aider git integration
• Aider linting and testing
• Aider in-chat commands
• Aider conventions
• Aider YAML config
• Aider LLM leaderboards
• Aider HISTORY changelog
• Aider LLMs / providers
• Introducing Claude Opus 4.5 (Anthropic)
• GPT-5.5 announcement (OpenAI community)
• Anthropic sub-agents docs
• OpenAI Codex CLI features
• Marktechpost on Claude Opus 4.8 (reported)