Appendix I: The Full Spectrum of AI Coding Tools

Warning

To-Do: This section needs expanding with more tools and/or kept up to date with new trends. A few tools removed their free tier recently so the lists need to be updated.

Beyond the three scenarios

The main course presents three scenarios as a simplified framework for understanding AI-assisted coding. In reality, the landscape is far more diverse. This appendix provides a comprehensive overview of the full spectrum of tools available, helping you explore options beyond what we covered in the core material.

Why a spectrum, not categories?

The three scenarios in this course—chat-based, IDE-integrated, and agentic—are useful teaching abstractions, but real-world tools often blur these boundaries:

Some IDE plugins have agentic capabilities
Some terminal agents are more conservative than IDE extensions
Some tools span multiple categories depending on how you configure them
New hybrid approaches emerge regularly

Understanding the full spectrum helps you:

Find tools that match your specific workflow
Evaluate new tools as they emerge
Combine tools effectively (many practitioners use 2-3 together)

A practical taxonomy

Rather than rigid categories, think of AI coding tools along several dimensions:

+----------------------+        +----------------------+        +----------------------+
|  Where you type      |        |  Where code changes  |        |  Where changes land  |
|  (UI / surface)      |        |  are produced        |        |  (collaboration)     |
+----------------------+        +----------------------+        +----------------------+
| AI-native editor     |  --->  | IDE plugin agent     |  --->  | PR / repo agent      |
| (Cursor/Windsurf)    |        | (Cline/Continue/...) |        | (issue -> PR)        |
+----------------------+        +----------------------+        +----------------------+
          |                                |                               |
          v                                v                               v
+----------------------+        +----------------------+        +----------------------+
| Terminal / CLI agent |        | Review/governance    |        | Orchestration        |
| (Claude/Codex/aider) |        | (CodeRabbit, etc.)   |        | (multi-agent mgmt)   |
+----------------------+        +----------------------+        +----------------------+

Key dimensions that vary across tools

Dimension	Range
Context source	Editor buffer only ↔ Entire repository ↔ PR/issue metadata
Action surface	Inline suggestions ↔ Multi-file patches ↔ Full branches/PRs
Safety model	Read-only ↔ Ask before each action ↔ Autonomous execution
Review loop	Immediate inline ↔ Diff review ↔ PR review with CI
Deployment	Cloud-only ↔ Hybrid ↔ Fully local

Tool categories in detail

1. AI-native editors / IDEs

These are full editors where AI agents and chat are first-class citizens of the interface—not add-ons, but core to the experience.

Tool	Description	Key Features
Cursor	VS Code fork with deep AI integration	Composer for multi-file edits, Tab for inline completion, Agent mode
Windsurf	AI-first IDE by Windsurf (ex Codeium)	Flows for multi-step tasks, Cascade for autonomous work

Best for: Developers who want AI deeply integrated into navigation, refactoring, and the entire editing experience, all in one environment.

Metaphor: Pair programming at the same workbench

Using an AI-native editor feels like having a navigator sitting next to you, able to see your screen, make suggestions, and take over typing when you describe what you want.

2. IDE plugins and extensions

Extensions that add AI capabilities to existing IDEs (VS Code, JetBrains, etc.). These range from simple autocomplete to full agent capabilities.

Tool	IDE	Features	Local Model Support
GitHub Copilot	VS Code, JetBrains, Neovim	Inline completion, chat, agent mode	No
Continue	VS Code, JetBrains	Chat, editing, agent workflows	Yes (Ollama)
Cline	VS Code	Agent that edits files and runs commands	Yes (Ollama)
Amazon Q Developer	VS Code, JetBrains	Completion, chat, security scanning	No
Tabnine	Multiple IDEs	Completion, chat	Yes (local models)
Sourcegraph Cody	VS Code, JetBrains	Chat, completion, codebase context	No
JetBrains Junie	JetBrains IDEs	Native AI agent for JetBrains	No

Best for: Developers who want to stay in their familiar IDE while adding AI capabilities incrementally.

3. Terminal / CLI agents

Agents you invoke from the command line that operate on local repositories, run commands, and propose diffs. Often feel like delegating to a teammate.

Tool	Description	Key Features
Claude Code	Anthropic’s terminal agent	Git-aware, sandboxing, permission system
Codex CLI	OpenAI’s terminal agent	Shell integration, code generation
Gemini CLI	Google’s terminal agent	Google Cloud integration
aider	Open-source pair programming	Git integration, multiple model support, local models
Open Interpreter	Open-source local agent	Runs code locally, multiple language support

Best for: Developers with shell- and git-centric workflows who prefer “delegate then review diffs” over constant inline suggestions.

Metaphor: Delegation to a teammate who can roam the repo

Using a CLI agent feels like giving a task to a colleague: “Add authentication to this Flask app.” They go away, work on it, and come back with changes for you to review.

4. Repository / PR-native cloud agents

Hosted agents that take issues or tasks and return complete branches or pull requests. They operate asynchronously and integrate with your existing PR workflow.

Tool	Description	Key Features
GitHub Copilot Workspace	Issue-to-PR automation	Plans changes, creates PRs
GitHub Copilot coding agent	Assignable agent for issues	Works like a team member
Google Jules	Asynchronous coding agent	Takes issues, returns PRs
Devin	“AI software engineer”	End-to-end task completion
Replit Agent	Browser-based agent	Full project generation

Best for: Teams with PR-driven workflows who want issue-to-implementation automation with CI integration and review gates.

5. Review and governance agents

Tools that focus on code review, security scanning, style enforcement, and policy compliance. They operate on PRs rather than generating code.

Tool	Description	Key Features
CodeRabbit	AI-powered PR review	Security, style, documentation checks
Codacy	Automated code review	Quality gates, security scanning
SonarQube	Code quality platform	Security, reliability, maintainability

Best for: Teams that want consistent review standards, security enforcement, and audit trails on all code changes.

6. Orchestration and multi-agent management

Dashboards and frameworks for coordinating multiple agents, managing sessions, or running agents across multiple repositories.

Tool	Description	Key Features
GitHub Agent HQ	Dashboard for Copilot agents	Monitor multiple agents
OpenHands	Open-source agent framework	Multi-agent orchestration
SWE-agent	Research agent framework	Academic research on coding agents

Best for: Organizations running multiple agents across projects who need visibility and coordination.

7. Self-hosted and local-first options

For maximum privacy and control, you can run models locally and connect them to your development environment. This is covered in detail in Appendix II: Running Local LLMs for Coding.

Key components:

Component	Examples	Role
Model runner	Ollama, llama.cpp, LM Studio	Runs the model locally
IDE extension	Continue, Cline	Connects your editor to the model
Model	Qwen2.5-Coder, DeepSeek-Coder	The actual LLM

Why go local?

Privacy: Code never leaves your machine
Offline: Works without internet
Cost: No API fees after initial setup
Control: Choose and customize your models

See Appendix II for complete setup guide

Appendix II: Running Local LLMs for Coding provides step-by-step instructions for setting up a local AI coding assistant with Ollama and Continue in VS Code, including model recommendations and configuration examples.

Community techniques and workflows

Beyond the tools themselves, practitioners have developed reusable workflows for making AI-assisted coding more reliable and safe.

Context control techniques

Technique	Description	Used by
Repo Map	Generate a compact map of files/symbols for high-signal context	aider
Memory Bank	Structured folder of persistent project notes the agent reads/updates	Cline users
Rules files	Conventions in files the tool auto-loads (`.cursorrules`, `CLAUDE.md`)	Cursor, Claude Code

Reliability loops

Technique	Description
Spec/PRD-first	Start from a checklist; use it as the anchor throughout
Tests-as-spec	Encode requirements as failing tests; iterate until green
Micro-commits	Small commits, frequent review, easy revert/squash

Safety and isolation

Technique	Description
Approval modes	Default to “ask before running”; expand autonomy only when bounded
Parallel worktrees	Run multiple agents in isolated git working copies
Transcript archiving	Save sessions for auditing, sharing, and debugging

The “Ralph loop” (named community pattern)

A workflow pattern for Claude Code and similar agents:

Start with a PRD/checklist
Run short, fresh agent sessions (one chunk at a time)
Run tests/lint after each session, capture errors
Feed errors back to a new session
Commit progress after each successful chunk
Repeat until the PRD is complete

The key insight: fresh sessions with persisted state (via files/commits) often work better than long sessions that accumulate context errors.

How to choose: A decision guide

Most practitioners end up using 2-3 tools together. Use this guide to find your starting point.

Pick an AI-native editor if…

You want the agent deeply integrated into navigation and refactoring
You prefer a single environment over mixing tools
You value fast iteration with inline suggestions plus multi-file edits

Pick an IDE plugin agent if…

You already live in VS Code/JetBrains and don’t want to switch
You need strong project-context features plus agent actions
You want to connect to local models while keeping your familiar IDE

Pick a terminal/CLI agent if…

Your workflow is shell- and git-centric
You prefer “delegate then review diffs” over constant inline pairing
You want something editor-agnostic (works from any environment)

Add PR/repo agents and review agents if…

You work in a PR-driven team and want issue → PR automation
You want consistent review, security, and style enforcement
You need a durable audit trail (PRs, CI logs)

Consider local/self-hosted options if…

Privacy is a primary concern (sensitive code or data)
You want to avoid sending code to external services
You’re willing to trade some capability for full control
Your institution restricts cloud AI services

Operational recommendations

Regardless of which tools you choose, these defaults serve most practitioners well:

Recommended operational defaults

Start conservative: Use approval prompts for commands and sensitive edits
Keep secrets out of context: Use env vars and secret managers, never paste keys
Prefer small diffs: Micro-commits and frequent reviews reduce risk
Use CI as referee: Run tests/lint in every loop; treat failures as feedback
Isolate parallel work: Worktrees/branches per task; avoid concurrent edits
Archive decisions: Rules files plus design notes keep future sessions grounded

Glossary

Term	Definition
Agentic coding	Tools that can plan, edit multiple files, run commands, and iterate toward a goal
FIM completion	Fill-in-the-middle code completion (insert within existing code)
Local LLM	A model served on your machine rather than a hosted API
OpenAI-compatible endpoint	A server that mimics OpenAI’s API for client compatibility
Worktree	Git feature for multiple working directories tied to one repo

Comprehensive tool list

This is a consolidated reference of all tools mentioned in this appendix.

AI-native editors

IDE plugins and agents

Terminal/CLI agents

PR/repo agents

Review and governance

CodeRabbit