aider

Aider maintains a live map of the entire local git repository's codebase structure, enabling the AI to understand project context and make coordinated edits across multiple files simultaneously. When changes are made, aider automatically stages, commits, and generates sensible commit messages based on the modifications, integrating directly with git's object model rather than treating files as isolated units. This approach allows the AI to reason about cross-file dependencies, maintain consistency across a project, and provide an auditable history of AI-driven changes.

Aider accepts context through multiple input channels — text chat, voice-to-speech transcription, image/screenshot uploads, web page URLs, and IDE code comments — and synthesizes them into a unified conversation context for the AI. Voice input is transcribed to text before being sent to the LLM; images and web pages are likely processed through vision APIs or HTML parsing; IDE comments are monitored via file-watching and injected as chat messages. This multi-modal approach reduces friction for developers who want to provide context in their most natural form.

Aider supports multiple configuration methods with a clear precedence hierarchy: command-line flags (highest priority), environment variables, and YAML configuration files (lowest priority). Users can specify API keys, model selection, project-specific settings, and other options through any of these methods. This flexibility allows for different workflows — quick one-off commands via CLI flags, persistent settings via config files, and secure credential management via environment variables.

Aider offers an 'ask' mode that allows users to ask questions about their code without triggering automatic file modifications. In this mode, the AI provides explanations, suggestions, and analysis without generating code changes or creating git commits. This is useful for code review, understanding existing code, or getting advice before making changes manually.

Aider includes a 'help' mode that provides in-terminal documentation about available commands, options, and usage patterns. This mode likely displays command syntax, examples, and explanations without entering the interactive chat interface.

Aider provides some visibility into token usage and costs, displaying aggregate metrics like '15B Tokens/week' on the homepage. However, per-session cost breakdown and detailed token accounting are not documented, making it unclear whether users can see costs for individual requests or estimate costs before making changes. The implementation likely involves logging API responses that include token counts, but the user-facing reporting mechanism is undocumented.

Aider provides a comprehensive configuration system (aider/args.py, aider/models.py) that allows developers to customize model behavior, set API keys, define model aliases, and configure advanced settings like thinking tokens and reasoning budgets. Configuration can be set via command-line arguments, environment variables, or configuration files. Model aliases enable shorthand names for complex model configurations (e.g., 'gpt4' for 'gpt-4-turbo-2024-04-09').

Aider includes a help system (aider/website/docs) with context-aware documentation that can be queried from the CLI. The HelpCoder component assembles relevant documentation based on the user's question and provides targeted help without leaving the CLI. This enables developers to learn Aider's features and troubleshoot issues without switching to external documentation.

Aider collects anonymous usage analytics (aider/website/assets/sample-analytics.jsonl) to track how the tool is used and identify improvement opportunities. The system logs events like model usage, feature adoption, and error rates. This data is used to guide development priorities and understand user behavior patterns. Analytics are anonymized and can be disabled by users.

Aider integrates with the user's local linting and testing infrastructure by executing linters and test suites after each code modification, capturing their output, and feeding errors back to the AI to automatically fix detected issues. This creates a feedback loop where the AI generates code, tests are run, failures are reported, and the AI iterates until tests pass and linting rules are satisfied. The mechanism relies on subprocess execution of configured linters/test runners and parsing their output formats.

Aider offers an 'architect' mode that shifts the AI's behavior from immediate code generation to high-level design discussion and planning. In this mode, the AI is expected to reason about system architecture, propose solutions, and discuss trade-offs before writing code. The exact mechanism for enforcing this mode (e.g., system prompt modification, token budget constraints, or output format restrictions) is undocumented, but it likely involves instructing the AI to prioritize explanation over implementation.

Aider abstracts over multiple LLM providers (OpenAI, Anthropic, Google, Groq, xAI, Azure, Cohere, Amazon Bedrock, GitHub Copilot, Vertex AI) and local model runners (Ollama, LM Studio, llama.cpp via OpenAI-compatible APIs) through a unified model selection interface. Users specify a model via `--model provider/model-name` and provide API keys through command-line flags, environment variables, or YAML config files. The abstraction layer translates aider's internal prompts and function-calling schemas into provider-specific formats, enabling seamless switching between cloud and local models without code changes.

Aider implements prompt caching (likely using OpenAI's or Anthropic's native caching APIs) to avoid re-sending unchanged context (e.g., large codebase maps, system prompts, previous conversation turns) to the LLM on subsequent requests. This reduces both API costs (cached tokens are cheaper) and latency (cached context is retrieved faster). The caching mechanism is transparent to the user and automatically managed by aider based on which parts of the context have changed between turns.

Aider provides an interactive terminal-based chat interface where users type natural language requests and receive AI responses in a conversational loop. The interface supports in-chat commands (e.g., `/add`, `/model`, `/help`) that allow users to control aider's behavior without leaving the chat — such as adding files to context, switching models, or viewing help. The REPL maintains conversation history within a session, allowing the AI to reference previous turns and maintain coherent multi-turn conversations.

Aider allows users to specify their project's coding conventions, style guides, and architectural patterns through natural language instructions or configuration files. The AI reads these conventions and applies them consistently across all generated code, ensuring that AI-generated changes conform to the project's standards without requiring manual style fixes. This is implemented by including convention descriptions in the system prompt or context sent to the LLM.

Aider can monitor files in your IDE and automatically respond to specially-formatted comments in your code. When you add a comment like `# TODO: aider - implement this function`, aider detects the comment, extracts the request, and generates code to fulfill it without requiring manual chat interaction. This creates a workflow where developers can request AI changes inline with their code, and aider responds asynchronously by modifying the file and committing changes.

Aider supports code generation and editing across 100+ programming languages including Python, JavaScript, Rust, Ruby, Go, C++, PHP, HTML, CSS, and many others. The AI understands language-specific syntax, idioms, and best practices for each language, and can generate code that follows language conventions. This is achieved through the LLM's training data and the codebase map providing language context (file extensions, existing code patterns).