cli-ai-tools

CLI AI Coding Tools Reference

Comprehensive reference for all major command-line AI coding assistants. This covers installation, key commands, flags, configuration, and model selection for each tool.

Tool Index

Tool	Provider	Primary Use
Claude Code	Anthropic	Agentic coding, full codebase understanding
Codex CLI	OpenAI	Agentic coding with sandboxed execution
Gemini CLI	Google	Agentic coding with Gemini models
Aider	Open Source	AI pair programming, git-integrated
Goose	Block	Extensible AI agent with plugins
amp	Sourcegraph	AI agent for large codebases
Copilot CLI	GitHub	Command-line suggestions and explanations
Cody CLI	Sourcegraph	Codebase-aware AI assistant
OpenCode	Open Source	Go-based terminal AI coding
qodo	Qodo	AI code quality and testing
Jules	Google	Async coding agent (GitHub-integrated)
Continue	Open Source	AI code assistant (IDE + CLI)
avante	Open Source	Neovim AI plugin (CLI-adjacent)

---

Anthropic: Claude Code

The CLI agent currently running in this session. Agentic AI coding with deep codebase understanding, tool use, and MCP integration.

Install:

npm install -g @anthropic-ai/claude-code

Basic usage:

claude                          # interactive REPL
claude "explain this codebase"  # start with a prompt
claude -p "what does main do"   # print mode (non-interactive, outputs to stdout)
claude --resume                 # resume last conversation
claude --continue               # continue last conversation with new input

Key flags:

Flag	Description
--model <model>	Select model (e.g. claude-sonnet-4-20250514)
-p, --print	Print mode: non-interactive, single response to stdout
--resume	Resume the most recent conversation
--continue	Continue last conversation with new input
--dangerously-skip-permissions	Skip all permission prompts (use with caution)
--allowedTools <tools>	Comma-separated list of allowed tools
--output-format <fmt>	Output format: text, json, stream-json
--max-turns <n>	Limit autonomous turns in non-interactive mode
--verbose	Enable verbose logging

Slash commands (interactive mode):

Command	Description
/help	Show all available commands
/compact	Compress conversation to save context
/clear	Clear conversation history
/config	View/edit configuration
/permissions	Manage tool permissions
/install-plugin <url>	Install a plugin from GitHub
/mcp	Manage MCP server connections
/model	Switch model mid-conversation
/cost	Show token usage and cost
/doctor	Diagnose installation issues

Configuration:

• Project config: .claude/settings.json in project root
• User config: ~/.claude/settings.json
• Memory: CLAUDE.md files (project root, ~/.claude/CLAUDE.md)
• MCP servers: .claude/mcp.json

Environment variables:

ANTHROPIC_API_KEY=sk-ant-...        # API key
CLAUDE_MODEL=claude-sonnet-4-20250514  # Default model
ANTHROPIC_BASE_URL=...              # Custom API endpoint

---

OpenAI: Codex CLI

OpenAI's open-source agentic coding CLI. Runs code in a sandboxed environment with network-disabled containers.

Install:

npm install -g @openai/codex

Basic usage:

codex                           # interactive mode
codex "refactor the auth module"  # start with prompt
codex --approval-mode full-auto "fix all tests"  # fully autonomous

Key flags:

Flag	Description
--model <model>	Select model (default: codex-mini-latest)
--approval-mode <mode>	suggest (default), auto-edit, full-auto
--quiet	Minimal output
-p, --prompt	Non-interactive single prompt

Approval modes:

• suggest — asks before every action
• auto-edit — auto-approves file edits, asks for commands
• full-auto — auto-approves everything (sandboxed)

Configuration:

• Config file: ~/.codex/config.yaml or ~/.codex/config.json
• Instructions: AGENTS.md in project root (similar to CLAUDE.md)

Environment variables:

OPENAI_API_KEY=sk-...               # API key
CODEX_MODEL=codex-mini-latest       # Default model

---

Google: Gemini CLI

Google's CLI coding assistant powered by Gemini models. Free tier available with Google account.

Install:

npm install -g @google/gemini-cli
# Or run without installing:
npx @google/gemini-cli

Basic usage:

gemini                          # interactive mode
gemini "explain this function"  # start with prompt
gemini -p "summarize README"   # non-interactive print mode

Key flags:

Flag	Description
--model <model>	Select model (e.g. gemini-2.5-pro)
-p	Non-interactive print mode
--sandbox	Run in sandboxed mode
--debug	Enable debug output

Configuration:

• Config: ~/.gemini/settings.json
• Memory: GEMINI.md in project root
• Supports MCP servers via .gemini/mcp.json

Environment variables:

GOOGLE_API_KEY=...                  # API key (or use Google auth)
GEMINI_MODEL=gemini-2.5-pro        # Default model

---

Google: Jules

Google's asynchronous coding agent. Integrates with GitHub — tasks are assigned via issues and Jules works on them in the background, creating PRs.

Usage:

• Accessed via jules.google.com or GitHub integration
• Not a traditional CLI tool — operates asynchronously on GitHub repos
• Assign tasks via GitHub issues or the Jules web interface
• Jules creates branches, makes changes, submits PRs

Key features:

• Async operation (runs independently in the background)
• GitHub-native integration
• Multi-file changes with PR creation
• Powered by Gemini models

---

Open Source: Aider

The most popular open-source AI pair programming CLI. Deep git integration, multi-model support, architect/editor pattern.

Install:

pip install aider-chat
# Or:
pipx install aider-chat
# Or with uv:
uv tool install aider-chat

Basic usage:

aider                               # interactive, auto-detects git repo
aider --model claude-3.5-sonnet     # specify model
aider file1.py file2.py             # add files to context
aider --architect                   # architect mode (plan then edit)

Key slash commands (interactive):

Command	Description
/add <file>	Add file(s) to the chat context
/drop <file>	Remove file(s) from context
/run <cmd>	Run a shell command and share output
/diff	Show pending diffs
/commit	Commit changes with AI-generated message
/undo	Undo the last change
/model <name>	Switch model
/architect	Toggle architect mode
/ask	Ask without editing (question-only mode)
/lint	Lint changed files
/test	Run tests
/tokens	Show token usage
/clear	Clear chat history
/exit	Exit aider

Key flags:

Flag	Description
--model <model>	Main model for editing
--architect	Use architect mode (separate planning model)
--editor-model <model>	Model for code edits (in architect mode)
--auto-commits / --no-auto-commits	Toggle auto-commit after each change
--watch-files	Watch files for changes and auto-add
--no-git	Disable git integration
--yes	Auto-confirm prompts
--edit-format <fmt>	whole, diff, udiff, diff-fenced

Configuration:

• Config file: .aider.conf.yml (project root or ~/.aider.conf.yml)
• Environment: .env file in project root
• Model aliases: .aider.model.settings.yml
• Environment variables: ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY, AIDER_MODEL

---

Block: Goose

Block's open-source AI agent CLI. Extensible with a plugin system called "extensions" (formerly "toolkits").

Install:

# macOS
brew install block/tap/goose

# Or from source
cargo install goose-cli

# Or via installer script
curl -fsSL https://github.com/block/goose/releases/latest/download/install.sh | bash

Basic usage:

goose session             # start interactive session
goose session -r          # resume last session
goose run "fix tests"     # run with a prompt
goose configure           # configure settings

Key commands:

Command	Description
goose session	Start a new session
goose session -r	Resume last session
goose run <prompt>	Run a single task
goose configure	Interactive configuration
goose info	Show current configuration

Configuration:

• Config file: ~/.config/goose/config.yaml
• Supports multiple providers: OpenAI, Anthropic, Google, Ollama, local models
• Extensions (plugins) for additional capabilities

---

Sourcegraph: amp

Sourcegraph's AI coding agent for the terminal. Designed for large codebase understanding.

Install:

# Download from https://ampcode.com
# Or via npm (check current package name):
npm install -g @anthropic-ai/amp

Basic usage:

amp                         # interactive mode
amp "explain the auth flow" # start with prompt
amp --continue              # continue last conversation

Key features:

• Thread-based conversations (similar to Claude Code)
• Codebase indexing and search
• Multi-file editing
• Git-aware operations

Configuration:

• Config: ~/.amp/settings.json
• Memory: AMP.md in project root

---

GitHub: Copilot CLI

GitHub Copilot's CLI integration. Provides command suggestions and explanations via the gh CLI extension.

Install:

gh extension install github/gh-copilot

Key commands:

Command	Description
gh copilot suggest "find large files"	Get command suggestions
gh copilot explain "tar -xzf file.tar.gz"	Explain a command

Flags:

Flag	Description
-t shell	Target: generic shell command
-t git	Target: git command
-t gh	Target: GitHub CLI command

Examples:

gh copilot suggest -t git "squash last 3 commits"
gh copilot explain "find . -name '*.log' -mtime +30 -delete"
gh copilot suggest -t shell "monitor CPU usage"

---

Sourcegraph: Cody CLI

Sourcegraph's AI coding assistant with CLI capabilities. Strong at codebase search and understanding.

Install:

npm install -g @sourcegraph/cody

Basic usage:

cody chat "explain this repo"    # ask questions
cody auth login                  # authenticate
cody auth status                 # check auth

Configuration:

• Auth: Sourcegraph access token or SRC_ACCESS_TOKEN env var
• Endpoint: SRC_ENDPOINT for self-hosted Sourcegraph

---

Open Source: OpenCode

Go-based AI coding assistant for the terminal. Lightweight TUI with multi-provider support.

Install:

go install github.com/opencode-ai/opencode@latest
# Or download binary from releases

Basic usage:

opencode                        # launch TUI

Configuration:

• Config file: opencode.json in project root
• Supports: OpenAI, Anthropic, Google, Groq, local models
• Provider-specific API keys via environment variables

---

Qodo: qodo

AI-powered code quality and test generation tool.

Install:

pip install qodo
# Or:
npm install -g qodo

Key commands:

qodo test <file>                # generate tests
qodo review <file>              # code review
qodo improve <file>             # suggest improvements

---

Neovim: avante.nvim

AI-powered Neovim plugin. CLI-adjacent — operates within Neovim's terminal-based interface.

Install: Add to Neovim plugin manager (lazy.nvim, packer, etc.):

{ "yetone/avante.nvim", build = "make" }

Key bindings (in Neovim):

• <leader>aa — Open Avante chat
• <leader>ae — Edit selected code with AI
• <leader>ar — Refresh AI response

Configuration:

• In Neovim config (init.lua)
• Supports: OpenAI, Anthropic, Azure, Ollama, Copilot

---

Other CLI-Adjacent Tools

The following are primarily IDE-based, not standalone CLI agents:

Tool	Type	Notes
Cline / Roo Code	VS Code extension	Cline forked as Roo Code. No standalone CLI binary.
Cursor	IDE (VS Code fork)	Open from terminal with cursor command.
Windsurf	IDE (Codeium)	Open from terminal with windsurf command.
Trae	IDE (ByteDance)	Open from terminal with trae command.
Continue	VS Code / JetBrains plugin	Config: ~/.continue/config.json. Supports all major providers.

---

Quick Model Selection Reference

Tool	Flag/Config	Example
Claude Code	--model	claude --model claude-sonnet-4-20250514
Codex CLI	--model	codex --model o4-mini
Gemini CLI	--model	gemini --model gemini-2.5-pro
Aider	--model	aider --model claude-3.5-sonnet
Goose	config file	goose configure then select provider/model
Copilot CLI	N/A	Uses GitHub Copilot model
OpenCode	config file	Set in opencode.json

---

Additional Resources

• references/tools-comparison.md — Detailed side-by-side feature comparison table across all CLI AI coding tools, covering capabilities, model support, pricing, and platform availability.
• references/common-patterns.md — Common usage patterns shared across CLI AI tools: context management, multi-file editing, git integration, MCP server configuration, and model routing strategies.