Exploring Modern Coding Agents: Tools, Implementations, and Insights

Previous Review

We previously examined the principles of Cursor and its edit_file tool; now we broaden the investigation to other coding agents.

Coding Agent List

VSCode Plugins

Cline – GitHub: https://github.com/cline/cline , Website: https://cline.bot/

GitHub Copilot – GitHub: https://github.com/microsoft/vscode-copilot-chat , Website: https://github.com/features/copilot

IDE

Cursor – GitHub: https://github.com/cursor/cursor , Website: https://cursor.sh/

Command Line

Claude Code – GitHub: https://github.com/anthropics/claude-code , Docs: https://docs.anthropic.com/en/docs/claude-code/overview

Gemini CLI – GitHub: https://github.com/google-gemini/gemini-cli , Docs: https://developers.google.com/gemini-code-assist/docs/gemini-cli

Aider – GitHub: https://github.com/Aider-AI/aider

OpenCode – GitHub: https://github.com/opencode-ai/opencode

Tools List

Horizontal Comparison

Claude Code’s tool names are similar to Aider, suggesting it may have been derived from Aider.

Cursor

Search and Discovery

codebase_search – semantic codebase search

grep_search – regex text search

file_search – fuzzy file‑path search

web_search – web information search

list_dir – list directory contents

File System Operations

read_file – read file content

edit_file – edit or create file with language support

delete_file – delete file

reapply – reapply previous edit when a failure occurs

Command Execution

run_terminal_cmd – execute terminal commands, run scripts and programs

Knowledge Management

update_memory – store or update project‑related memory for context continuity

GitHub Integration

fetch_pull_request – retrieve PR or commit details

fetch_github_issue – retrieve issue information and discussion

Content Generation

create_diagram – generate Mermaid diagrams for visualising flows and architectures

Gemini CLI

list_directory – list files and directories

read_file – read file content

search_file_content – regex search within files

glob – pattern‑based file matching

write_file – write content to a file

run_shell_command – execute shell commands

save_memory – persist data to long‑term memory

google_web_search – perform web searches

Claude Code

Bash – execute shell commands

Read – read from the file system

Write – write to the file system

MultiEdit – perform multiple edits in a file

Glob – file pattern matching

Grep – search file contents

LS – list directories

WebSearch – search the web

WebFetch – fetch web page content

TodoRead / TodoWrite – manage todo lists

NotebookRead / NotebookEdit – read and edit Jupyter notebooks

Aider

File Operations: Read, Edit (precise string replacement), MultiEdit, Write

Notebook Operations: NotebookRead, NotebookEdit

OpenCode

bash – command execution

edit – find/replace file editing

fetch – HTTP content retrieval

glob – file pattern matching

grep – regex content search

ls – directory listing

sourcegraph – public code repository search

view – file view with line numbers

patch – multi‑file patch application

agent – sub‑agent generation

Edit Tool Implementation (Cline)

Parameters file_path (string): absolute path of the file to modify edits (array): each edit contains old_string (string) and new_string (string)

Output Format

Returns a structured result describing the ordered file modifications, supporting diff‑style SEARCH/REPLACE blocks, streaming JSON replacements, and error handling with specific error types.

------- SEARCH
old content here
=======
new content here
+++++++ REPLACE

Algorithm Details

Sequential processing with lastProcessedIndex to maintain edit order

Greedy matching using exact indexOf search (O(n·m))

Fallback strategies: line‑trimmed matching, block‑anchor matching, full‑file search

Complexity: best O(n), average O(n·m), worst O(n·m·k·4)

Key Features

Order‑preserving edits

Greedy first‑match without backtracking

No fuzzy matching; relies on exact or trimmed matches

Anchor‑based optimization using first and last lines of a block

Layered fallback chain from precise to full‑file search

Gemini CLI Implementation

Parameters file_path (string, required): absolute file path old_string (string, required): text to replace new_string (string, required): replacement text expected_replacements (number, optional, default 1): expected number of replacements

Output

Success: message like “Successfully modified file: {path} ({count} replacements)” or a FileDiff object

Error: descriptive message such as “Failed to edit, could not find the string to replace”

Implementation Steps

Read the file into memory ( fs.readFileSync).

Perform replacement using replaceAll() (or replace() for single occurrence).

Write the modified content back to disk ( fs.writeFileSync).

Core Algorithm

function editFile(content, oldString, newString, replaceAll) {
  if (replaceAll) {
    return content.replaceAll(oldString, newString);
  } else {
    const index = content.indexOf(oldString);
    if (index === -1) throw new Error("String not found");
    if (content.indexOf(oldString, index + 1) !== -1) {
      throw new Error("Multiple matches found, use replace_all or provide more context");
    }
    return content.replace(oldString, newString);
  }
}

Complexities

Time: O(n·m) where n is file size, m is pattern length

Space: O(n) for the original content plus O(n) for the new content (≈2× file size)

Thoughts

After reviewing many tools, I feel that at the tool‑usage level the various coding agents share no fundamental differences; the key capabilities of a coding agent remain:

A complete file system for search and file‑operation tools.

A sandboxed Windows/Unix environment for run_terminal_cmd to execute system commands.

Internet search abilities, both generic web search and GitHub‑specific queries.

An efficient edit_file implementation that can apply precise, possibly AI‑generated, patches without re‑generating the whole file.

A semantic search/indexing capability powered by embedding models and a vector store.