AI Coding Assistants

The Landscape

AI coding assistants are the tools you use daily as a developer. They range from inline autocomplete to full agentic systems that read, write, and run your code.

                       Less Agentic ←──────────→ More Agentic

  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
  │   Copilot    │  │   Cursor     │  │  Claude Code │  │   Devin      │
  │  (inline +   │  │  (IDE with   │  │  (CLI agent, │  │  (autonomous │
  │   chat)      │  │   composer)  │  │   full repo) │  │   agent)     │
  └──────────────┘  └──────────────┘  └──────────────┘  └──────────────┘
    Suggests code     AI-native IDE     Reads/writes/     Works alone on
    as you type       with commands     runs commands      full tasks

---

GitHub Copilot

The original and most widely used AI coding assistant. Made by GitHub (Microsoft) using OpenAI models.

Features

IDE Support

• VS Code (best integration)
• JetBrains (IntelliJ, PyCharm, WebStorm)
• Neovim
• Visual Studio

Strengths

• Seamless inline experience — minimal friction
• Deeply integrated with VS Code and GitHub ecosystem
• Good at completing boilerplate and patterns
• Copilot Workspace for PR-level changes

Limitations

• Inline suggestions can be wrong (always review)
• Limited agentic capabilities compared to Claude Code or Cursor
• Cannot run commands or access your terminal
• Suggestions based on surrounding code, not full repo understanding

Pricing

• Individual: $10/month or $100/year
• Business: $19/user/month
• Enterprise: $39/user/month

---

Cursor

A VS Code fork rebuilt around AI. Not just AI in an editor — the editor itself is designed for AI workflows.

Key Features

Workflow Example

1. Open Cursor in your project
2. Press Cmd+K in a file
3. Type: "Add input validation for email and password fields"
4. Cursor shows a diff — accept or reject each change
5. Use Composer for multi-file changes: "Add user authentication
   with JWT tokens, create the middleware, route, and tests"

Model Support

• Claude Sonnet/Opus
• GPT-4o
• Custom models via API key

Strengths

• Best-in-class inline editing (Cmd+K is genuinely faster than typing)
• Composer handles multi-file changes well
• Familiar VS Code interface (extensions, keybindings carry over)
• Strong codebase understanding via indexing

Limitations

• VS Code fork means slight lag behind VS Code updates
• Composer can hallucinate file paths or APIs
• Monthly cost on top of any model API costs

Pricing

• Hobby: Free (limited completions)
• Pro: $20/month (500 fast requests)
• Business: $40/user/month

---

Claude Code

Anthropic's CLI tool for agentic coding. It runs in your terminal, not your IDE.

How It Works

bash
$ claude
> "Add rate limiting to the Express API using redis, with 100 req/min per IP"

Claude Code:
1. Reads your project structure and relevant files
2. Plans the implementation
3. Creates/edits files (middleware, config, tests)
4. Runs npm install redis
5. Runs your tests to verify

Key Features

Strengths

• Most agentic: reads, writes, runs, and verifies
• Understands full project context (not just open files)
• Plan mode gives you control before execution
• Terminal-native — works over SSH, in tmux, anywhere
• No editor lock-in

Limitations

• No visual interface (terminal only)
• Requires comfort with CLI workflows
• No inline completions while typing
• Review diffs carefully — agentic changes can be broad

Pricing

• Included with Claude Pro ($20/month) or via API usage

---

Windsurf (Codeium)

Another VS Code fork with AI-native features. Made by the Codeium team.

Key Features

Strengths

• Cascade agent is powerful for multi-file tasks
• Good free tier for individual developers
• Smooth autocomplete experience

Pricing

• Free: Limited Cascade and autocomplete usage
• Pro: $15/month

---

Cline

An open-source VS Code extension for agentic coding. Supports multiple LLM providers.

Key Features

Strengths

• Open source and free (bring your own API key)
• Provider flexibility (switch models per task)
• Transparent — shows every action before executing
• Active community and rapid development

Limitations

• Costs depend on your API usage (can get expensive with Claude/GPT-4o)
• Quality depends heavily on which model you use
• Less polished than commercial alternatives

---

Aider

A terminal-based pair programming tool. Git-aware and conversation-driven.

bash
$ aider
> /add src/auth.py src/routes.py
> Add JWT authentication to the login route. Use python-jose for token creation.

Aider:
1. Reads the specified files
2. Shows proposed diff
3. Applies changes and creates a git commit automatically

Strengths

• Git-native: every change is a commit (easy to undo)
• Supports many models (Claude, GPT-4o, local models)
• Lightweight and fast
• Great for pair programming flow

Limitations

• Terminal only (no IDE integration)
• Need to manually specify which files to edit
• Less agentic than Claude Code (doesn't run tests automatically)

Pricing

• Free and open source (bring your own API key)

---

Continue

An open-source IDE extension (VS Code and JetBrains) that connects to any LLM.

Features

• Inline autocomplete from any model
• Chat panel with codebase context
• Custom slash commands
• Support for local models via Ollama

Strengths

• Works in both VS Code and JetBrains
• Fully configurable (choose your model, set your system prompt)
• Open source, privacy-friendly (supports local models)

---

Comparison Table

---

Getting the Most Out of Coding Assistants

1. Provide Context

Bad:  "Fix this bug"
Good: "The login function on line 45 of auth.py throws a KeyError when
       the user doesn't have a 'role' field. Add a default role of 'viewer'."

2. Be Specific

Bad:  "Make the code better"
Good: "Refactor getUserData to use async/await instead of callbacks.
       Keep the same function signature."

3. Review Everything

• AI-generated code can have subtle bugs
• Check edge cases the model may have missed
• Verify security implications (especially auth, SQL, user input)
• Run tests after every change

4. Iterate

Turn 1: "Write a function to parse CSV files"
Turn 2: "Add error handling for malformed rows"
Turn 3: "Support custom delimiters and quoted fields"
Turn 4: "Add type hints and make it a generator"

5. Use the Right Tool for the Job

---

Resources

• 🔗 GitHub Copilot
• 🔗 Cursor
• 🔗 Claude Code
• 🔗 Windsurf
• 🔗 Cline
• 🔗 Aider
• 🔗 Continue

---

Previous: 11 - ChatGPT & OpenAI | Next: 13 - Open Source Models