aider

Launches an interactive chat session in the terminal where developers type natural language prompts and receive code modifications in real-time. Aider maintains conversation context across multiple turns within a session, allowing iterative refinement of code changes through back-and-forth dialogue. The REPL integrates directly with the shell environment, requiring only `aider` command invocation in a git-initialized directory.

Automatically scans and indexes the entire local git repository to build an internal map of the codebase structure, file relationships, and code patterns. This map is used to provide the LLM with relevant context about the project without requiring developers to manually specify which files matter. The mapping mechanism reads git-tracked files and understands 100+ programming languages, enabling language-aware code generation across polyglot projects.

Implements prompt caching at the LLM provider level to reduce token consumption and latency for repeated requests. When the same codebase context or file content is used across multiple requests, aider caches the prompt tokens with the provider (e.g., OpenAI's prompt caching, Anthropic's prompt caching), avoiding re-processing of unchanged context. This reduces both API costs and response latency.

Integrates with git to provide undo and rollback capabilities for AI-generated changes. Developers can use standard git commands (`git diff`, `git reset`, `git revert`) to inspect, modify, or undo aider's changes. Each aider request results in a git commit, making it easy to revert specific changes or cherry-pick modifications. This leverages git as the source of truth for change management.

Allows developers to specify project-specific coding conventions, style guides, and architectural patterns that aider should follow when generating code. Conventions can be documented in configuration files or communicated in chat, and aider incorporates them into code generation to ensure consistency with existing code. This enables aider to match project style without explicit instruction for every request.

Supports code generation across 100+ programming languages including Python, JavaScript, TypeScript, Rust, Go, C++, Java, Ruby, PHP, HTML, CSS, and many others. The codebase mapping and code generation logic is language-agnostic, allowing aider to work equally well in polyglot projects. Language detection is automatic based on file extensions and content.

Provides a web-based chat interface as an alternative to the terminal REPL, allowing developers to interact with aider through a browser. The web interface supports the same capabilities as the terminal (code generation, file editing, git integration) but with a GUI. Developers can copy code from the browser and paste it into their editor, or use the web interface for code review before applying changes.

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.

Enables the LLM to modify multiple files in a single request while maintaining consistency across changes. Aider stages all modifications in git before committing, allowing developers to review the complete changeset. The editing system understands file dependencies and can coordinate changes across related files (e.g., updating imports when moving functions, modifying tests when changing APIs).

After each code modification, aider automatically commits changes to git with AI-generated commit messages that summarize the modifications. The commit message generation understands the context of the changes and produces messages following conventional commit patterns. This automation eliminates manual commit message writing while maintaining a clean git history.

Accepts voice input through the terminal, transcribes it to text using speech-to-text technology, and processes the transcribed prompt as a code request. Developers can speak natural language descriptions of features, bug fixes, or test cases, and aider converts them to code modifications. This capability enables hands-free coding for accessibility and rapid prototyping.

Accepts images, screenshots, and web pages as input to provide visual context for code generation requests. Developers can paste images of UI designs, architecture diagrams, or reference documentation into the chat, and aider uses vision capabilities to understand the visual content and generate corresponding code. This bridges the gap between design and implementation.

Automatically runs linters and test suites after each code modification, captures their output, and feeds errors back to the LLM for automatic fixing. Aider detects linting violations (style, type errors, etc.) and test failures, then iteratively modifies code until linters pass and tests succeed. This creates a feedback loop where the AI is responsible for code quality, not just functionality.

Monitors files in an IDE or editor for AI-specific comments (e.g., `// aider: add error handling`) and automatically processes those comments as code requests. Developers can annotate code with directives in their editor, and aider responds by modifying the file without requiring a separate terminal session. This bridges the gap between editor-based development and aider's terminal-first approach.

Provides a specialized mode where the LLM focuses on high-level architectural planning and design decisions rather than immediate code generation. In architect mode, aider helps developers think through system design, propose refactoring strategies, and plan multi-step implementations before writing code. This mode is optimized for planning-heavy tasks where code generation should follow design decisions.

Supports multiple LLM providers and models through a unified interface, allowing developers to switch between OpenAI, Anthropic, DeepSeek, Google Gemini, local models (Ollama, LM Studio), and 10+ other providers without changing their workflow. API keys are configured via environment variables, YAML config files, or command-line arguments. Developers can specify different providers for different requests or set a default provider.