Development Tools

Core Tools

Claude Code (Anthropic)

The reference commercial tool for agentic coding. Terminal integration, MCP support, GitHub integration.

# Install
pnpm add -g @anthropic-ai/claude-code

# Basic usage
claude "Build a Python calculator"

# Include file context
claude --file=PROMPT.md

# Headless mode (for Ralph Loop)
cat PROMPT.md | claude --headless

# /loop — schedule-based autonomous agent loop
claude /loop "find and fix failing tests" --every 2h --for 3d

# Check loop status / stop
claude /loop --status
claude /loop --stop

Key features:

MCP server integration (~/.claude/settings.json)
CLAUDE.md per-project instruction file
/loop schedule-based autonomous loop (git worktree isolation, up to 3 days)
Multi-file editing
GitHub Actions integration

Advanced features:

Planning & Control

Plan Mode (Shift+Tab) — Draft a plan before writing code. Once confirmed, auto-executes the plan.
Terminal window
```
# In an interactive session, press Shift+Tab to enter Plan Mode
# Draft plan → confirm → auto-execute
```
Effort Levels — Adjust reasoning depth. Use low effort for simple tasks to save cost; high effort for complex design work.
Terminal window
```
claude --effort low "What is the return type of this function?"
claude --effort high "Refactor this module to be async"
```

Output Styles — Cognitive mode presets: Explanatory, Learning, Concise, etc.

claude --output-style concise "Analyze test failure cause"
claude --output-style explanatory "Explain the MCP protocol"

Extension System

Custom Agents — Define specialized agents in .claude/agents/*.md. Declaratively set role, allowed tools, and permissions.

# After defining a role in .claude/agents/qa-reviewer.md:
claude --agent qa-reviewer "Review this PR"

// Set default agent in settings.json
{ "defaultAgent": "qa-reviewer" }

Skills — Installable .md skill files. Place in ~/.claude/skills/ and load within a session.
Terminal window
```
# Load a skill
claude /skills refactor-guide
```

Hooks — Shell commands triggered by events (tool calls, etc.). Configured in settings.json.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": "echo '$(date): Bash called' >> ~/.claude/audit.log"
      }
    ]
  }
}

Isolation & Safety

Sandboxing (/sandbox) — Isolate BashTool file and network access. Limits blast radius of agent mistakes.
Terminal window
```
# Activate sandbox mode
claude --sandbox
```

Worktree Native (--worktree) — Git worktree-based isolated sessions. Supports tmux integration for background execution.

# Start an isolated worktree session
claude --worktree feature-auth
# Run in background via tmux
claude --worktree feature-auth --tmux

Parallel Execution

Parallel Sessions — Run multiple Claude Code instances simultaneously. Each session maintains an independent context.

# Terminal 1: frontend work
claude --worktree frontend "Implement React components"
# Terminal 2: backend work
claude --worktree backend "Implement API endpoints"

/batch — Interactive planning followed by worktree-isolated parallel execution. Each agent tests and opens an individual PR.
Terminal window
```
claude /batch "Migrate logging in src/ to the new structured logger"
```
/simplify — Parallel-agent code review across reuse, quality, and efficiency dimensions.
Terminal window
```
claude /simplify
```

For detailed explanations and hands-on examples, see Week 4 (loops/worktree), Week 6 (instruction tuning), and Week 7 (multi-agent design).

Gemini CLI (Google)

Google’s AI coding CLI with a free tier. It supports a 1M token context window, Google Search grounding, MCP, and extensions.

# Install
pnpm add -g @google/gemini-cli

# Interactive mode
gemini

# Pipe mode (headless)
cat PROMPT.md | gemini

Key features:

MCP server integration (~/.gemini/settings.json)
GEMINI.md per-project instruction file
Free tier: 1,000 req/day
1M token context window
Google Search grounding
Extensions for tool integration

Codex CLI (OpenAI)

OpenAI’s terminal-based coding agent. Supports built-in sandboxing, AGENTS.md, MCP, skills, hooks, and subagents. Codex App/Web is a separate cloud-sandboxed surface for asynchronous coding work.

# Install
pnpm add -g @openai/codex

# Basic usage
codex "Build a Python calculator"

# Auto-approval mode (for Ralph Loop)
codex --approval-mode full-auto "$(cat PROMPT.md)"

Key features:

Built-in sandbox (safest automated execution)
AGENTS.md per-project instruction file
MCP server integration (~/.codex/config.toml or .codex/config.toml)
skills, hooks, subagents
Workflow across CLI, IDE extension, App/Web
Requires ChatGPT Plus or API key

OpenCode

Open-source TUI-based AI coding tool. Supports multiple model backends including local models.

# Install (macOS)
brew install opencode

# TUI mode
opencode

# API server mode
opencode serve

Key features:

TUI (Terminal UI) interface
Multiple backends: OpenAI, Anthropic, local models (Ollama), and more
Free when using local models (no API cost)
Limited MCP support

For a detailed comparison of tools, see the AI Coding Tool Selection Guide.

vLLM

High-throughput LLM inference server with an OpenAI-compatible API.

# Install
pip install vllm

# Start server
python -m vllm.entrypoints.openai.api_server \
  --model deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct \
  --port 8000

# Client usage (OpenAI-compatible)
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="token")

Model Context Protocol (MCP)

The standard protocol for connecting agents to external tools.

Key MCP servers:

Server	Function	Install
`@modelcontextprotocol/server-filesystem`	File read/write	`npx`
`mcp-server-git`	Git operations	`uvx`
`mcp-server-github`	GitHub API	`uvx`
`mcp-server-postgres`	PostgreSQL	`uvx`

// Gemini CLI: ~/.gemini/settings.json
// Codex CLI: ~/.codex/config.toml or .codex/config.toml
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/project"]
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git", "--repository", "."]
    }
  }
}

OpenTelemetry

The standard for collecting telemetry from agent systems.

pip install opentelemetry-sdk opentelemetry-exporter-prometheus

Open-Weight Coding LLMs

Major coding models that can be deployed locally. Serve them via vLLM or SGLang with an OpenAI-compatible API. This table reflects representative models as of 2026-05.

Model	Parameters	Active	Context	HuggingFace
Qwen3-Coder-Next	80B (MoE)	3B	256K	`Qwen/Qwen3-Coder-Next`
DeepSeek-V4-Pro	1.6T (MoE)	49B	1M	`deepseek-ai/DeepSeek-V4-Pro`
DeepSeek-V4-Flash	284B (MoE)	13B	1M	`deepseek-ai/DeepSeek-V4-Flash`
GLM-5.1	754B	see model card	long-context agent work	`zai-org/GLM-5.1`
MiniMax-M2.7	229B	MoE family, see model card	long agentic workflows	`MiniMaxAI/MiniMax-M2.7`
DeepSeek-Coder-V2	236B (MoE)	21B	128K	`deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct`
Qwen3 lightweight family	30B-A3B/14B/8B, etc.	varies	varies	`Qwen/*`

Current model cards:

For detailed per-model comparisons and hardware requirements, see Week 10 lecture.

Other Useful Tools

Tool	Purpose	Install
`uv`	Python package manager (pip alternative)	`pip install uv`
`Ruff`	Python linter/formatter	`pip install ruff`
`pytest`	Python test framework	`pip install pytest`
`mypy`	Python type checker	`pip install mypy`
`httpx`	Async HTTP client	`pip install httpx`