Esenciales de Programación en Pareja con Aider

What's in this pack

Aider is the OG. Before Claude Code, before Codex CLI, before Cursor's agent mode — Paul Gauthier shipped aider and proved you could pair-program with an LLM from a terminal, with a real git commit per edit. It still has the cleanest commit log of any agent and the widest model coverage (anything LiteLLM supports, which is 100+ providers).

This pack is for the developer who has heard about Aider, wants to try it seriously, and doesn't want to spend Saturday watching install videos. Ten picks, in install order, that get you from pip install aider-chat to a real workflow — config locked in, project guidelines auto-loaded, a cheap fallback model, watch mode so your editor of choice can trigger it, git tooling to actually review the commits, and the comparison guide so you know when to reach for Claude Code or Codex instead.

Who this is for: a terminal-comfortable developer working in a real codebase who values explicit edits + per-change git commits over agentic exploration. If you want autonomous multi-step planning, this is the wrong stack — go install Claude Code. If you want "AI as a precise scalpel that records every cut," keep reading.

Install in this order

1. Aider — AI Pair Programming in Your Terminal — pip install aider-chat, point at an API key, run aider file1.py file2.py. That's it. The whole experience is: name the files you want to edit, describe the change, watch Aider produce a diff and commit it. Five minutes to feel the loop; the rest of this pack is making it stop being clunky.
2. .aider.conf.yml — Production Aider Configuration — Drop this template in your project root. It pins your default model, your weak model for cheap turns, lint and test commands Aider runs after each edit, file ignores, and architect/editor model split. The single highest-leverage file after Aider itself. Without it you'll fight the defaults forever.
3. Awesome CLAUDE.md — Project Config Best Practices — Aider reads CONVENTIONS.md (or AGENTS.md, or whatever you point --read at) the same way Claude Code reads CLAUDE.md. The patterns in this collection — terse stack notes, hard NOs, naming rules — transfer directly. Pick one template, rename it CONVENTIONS.md, add it to .aider.conf.yml under read:.
4. LiteLLM Proxy — Unified Gateway for 100+ LLM APIs — Aider already speaks LiteLLM natively, but running the proxy gives you per-project keys, spend caps, and a unified log of every call. The proxy also lets you switch between Anthropic, OpenAI, OpenRouter, and local Ollama without touching .aider.conf.yml. Set this up before your first $300 month.
5. DeepSeek Coder — Code-Specialized Model for Local Inference — Aider's --weak-model is the cheap model it uses for commit messages and routine edits. DeepSeek Coder is the canonical cheap-and-good choice — runs locally via Ollama or through DeepSeek's API at a fraction of GPT-4 pricing. Big quality jump for negligible cost.
6. Aider Watch Mode — Auto-Edit on # AI: Comments — Run aider --watch-files and now any editor (VS Code, vim, Cursor, Claude Code, JetBrains) can trigger Aider just by saving a file containing # AI: comments. This bridges the "I want to stay in my IDE" gap. Aider runs in a terminal tab; you never leave your editor.
7. Git MCP — Version Control Server for AI Agents — Aider commits per edit; that's a feature. But the commit history becomes useful only when other tools can read it. Git MCP exposes the local repo to any MCP-aware agent (Claude Code, Cursor, Gemini CLI) so they can see exactly what Aider just did and reason about it. Pairs perfectly with the multi-agent setups in pick #10.
8. Lazygit — Simple Terminal UI for Git Commands — Aider's commit-per-edit is great in theory; in practice you'll want to squash 12 micro-commits into 1 PR-worthy commit before pushing. Lazygit's interactive rebase is the fastest way to do that without leaving terminal. Hit R on the base commit, mark commits as squash, write a clean message. 20 seconds vs 2 minutes of git rebase -i flag-juggling.
9. tmux — Terminal Multiplexer for Sessions, Windows, Panes — Aider in one pane, your test runner watching files in another, server logs in a third. The whole Aider experience improves 3x once you stop alt-tabbing. Detach the session, come back tomorrow, your model context is gone but Aider re-reads the files and you're back where you were.
10. AI Coding Agent Comparison 2026 — Complete Guide — Read this when Aider feels wrong. It will sometimes — multi-file refactors, exploratory work where you don't know which files to add, anything requiring tool use beyond shell. This guide tells you when to switch to Claude Code (agentic exploration), Codex CLI (autonomous tasks), or Cursor (IDE-integrated). Aider is a precision tool, not a swiss army knife.

How they fit together

Aider (#1)
   │
   └─ the edit loop: name files → describe → diff → commit
         │
.aider.conf.yml (#2)
   │
   ├─ pins model + weak model
   ├─ runs lint + test after edits
   └─ loads CONVENTIONS.md
         │
CONVENTIONS.md via Awesome CLAUDE.md (#3)
   │
   └─ project memory Aider reads every session
         │
LiteLLM Proxy (#4)
   │
   ├─ unified model gateway
   └─ spend caps per project
         │
DeepSeek Coder (#5)
   │
   └─ cheap weak-model for commit msgs + routine edits
         │
Watch Mode (#6)
   │
   └─ any editor → save # AI: comment → Aider edits
         │
Git MCP (#7) + Lazygit (#8)
   │
   ├─ Git MCP: other agents can read Aider's trail
   └─ Lazygit: squash micro-commits before push
         │
tmux (#9)
   │
   └─ Aider + tests + logs in one window
         │
Comparison Guide (#10) — know when to reach for a different tool.

The load-bearing trio is Aider + .aider.conf.yml + CONVENTIONS.md. Everything else is upgrade. If you only have 15 minutes: install #1, drop in #2, point it at a small CONVENTIONS.md and run.

Tradeoffs you'll hit — Aider vs Claude Code vs Codex CLI

• Aider vs Claude Code — Aider is explicit: you say "edit these 3 files" and it edits those 3 files. Claude Code is agentic: you describe the task and it decides which files to touch, runs tools, iterates. Aider wins on precision and git hygiene (every edit is a real commit you can revert). Claude Code wins on exploratory work and multi-step tasks. Use Aider for surgical changes you can describe in one sentence; use Claude Code when you'd otherwise spend 20 minutes finding the right files.
• Aider vs Codex CLI — Codex CLI is OpenAI's terminal agent — closer to Claude Code in mental model (autonomous, agentic). Aider is fundamentally different: human-driven, file-scoped, commit-per-edit. If you want OpenAI models with Aider's discipline, you can route Aider through GPT-4o via LiteLLM and get most of the Codex experience plus the commit log. If you want Codex's autonomy, Aider won't match it.
• Model split (architect vs editor) — Aider's killer feature most people skip: set architect_model: o1 (or Claude Opus) for planning, editor_model: claude-sonnet (or DeepSeek Coder) for the actual diff. Architect plans cheap and slow; editor edits fast and cheap. Quality goes up, cost goes down. The .aider.conf.yml template (#2) has this preconfigured.
• Commit-per-edit vs feature commits — Aider's default of one commit per edit feels noisy if you're used to crafting PR-worthy commits. Two options: (a) Lazygit (#8) squash before push; (b) --no-auto-commit and commit manually. Most people stick with auto-commit + squash because the per-edit history is invaluable when something breaks and you need to git bisect your AI sessions.

Common pitfalls

• Burning $50 in one session — Aider sends the whole file (or the whole repo map) on every turn. Without .aider.conf.yml setting a weak_model, every commit-message generation uses your expensive model. Set it up before you start. Watch /tokens inside Aider — it tells you the cost of the current context.
• Edit-mode confusion (whole vs diff vs udiff vs architect) — Aider has multiple edit formats and picks one per model. If edits are failing ("diff not applied"), check --edit-format. Sonnet does best with diff-fenced; o1 prefers architect mode where it plans then a cheaper editor model writes the diff. Read the model recommendations once; never think about it again.
• Auto-commits filling history with garbage — Yes, by default Aider commits everything. The fix isn't --no-auto-commit; it's discipline at PR time. Use Lazygit (#8) to squash the session into a single conventional commit. Or set up a pre-push hook that warns if you have more than N un-squashed AI commits.
• Forgetting /add and /drop — Aider only edits files you've added. Adding the whole repo blows context; adding too few files means edits skip files that need touching. Use /add file.py and /drop file.py liberally. The repo map (auto-included by default) is usually enough context for Aider to know what exists without you adding everything.
• Treating watch mode as a Cursor replacement — It's not. Cursor inlines suggestions in the editor; Aider watch mode requires you to save a # AI: comment and wait for a diff. Different mental model. If you want "AI types as you type," use Cursor or Copilot. If you want "I'll describe what I want and you do it precisely," Aider watch mode is the workflow.