IDE-Integrated Development Assistants

Relevant source files

• Amp/README.md
• Amp/claude-4-sonnet.yaml
• Amp/gpt-5.yaml
• Amp/view-thread-yaml.png
• Anthropic/Claude Code/Tools.json
• VSCode Agent/Prompt.txt
• Windsurf/Tools Wave 11.txt

This document covers AI coding assistants that integrate directly into Integrated Development Environments (IDEs), specifically Visual Studio Code and its derivatives. These systems operate as extensions or plugins within the IDE, providing real-time access to the development environment's features including file operations, terminal execution, diagnostics, and version control.

The four systems documented here are:

• VSCode Agent (GitHub Copilot's agent system)
• Windsurf Cascade (AI Flow paradigm implementation)
• Amp (Sourcegraph's coding agent)
• Claude Code (Anthropic's tool ecosystem)

For web-based development platforms that provide full environments in the browser, see Web-Based Development Platforms. For browser-focused automation assistants, see Browser and Conversational Assistants.

Distinguishing Characteristics

IDE-integrated assistants differ from web-based and browser-focused tools in several fundamental ways:

Characteristic	IDE-Integrated	Web-Based	Browser-Focused
Environment Access	Direct OS/shell access via extensions	Containerized cloud environments	Browser automation only
File System	Full local filesystem access	Project-scoped virtual filesystem	No direct file access
Tool Implementation	Extension API + native commands	Server-provided tools	Browser control protocols
State Persistence	Local workspace state	Server-side project state	Session-based state
Command Execution	Native shell (PowerShell, bash, zsh)	Docker containers	JavaScript execution only

Sources: VSCode Agent/Prompt.txt1-405 Windsurf/Tools Wave 11.txt1-383

Architecture Overview

Diagram: IDE-Integrated Agent Architecture

This architecture demonstrates how IDE-integrated agents leverage the extension API to access IDE capabilities. The tool registry serves as the primary interface between the agent core and the IDE environment.

Sources: VSCode Agent/Prompt.txt68-381 Anthropic/Claude Code/Tools.json1-390 Windsurf/Tools Wave 11.txt1-383

VSCode Agent (GitHub Copilot)

Identity and Operational Model

The VSCode Agent identifies itself as "GitHub Copilot" and operates as a highly sophisticated automated coding agent with expert-level knowledge across programming languages and frameworks. The system emphasizes autonomous task completion without requiring explicit user permission for tool execution.

Core Operational Principles:

• Autonomous tool usage without asking permission
• Mandatory read-before-edit workflow
• Preference for semantic search over exact pattern matching
• Parallel tool execution for independent operations (except semantic_search)
• Automatic validation after file modifications

Sources: VSCode Agent/Prompt.txt3-26

Tool Ecosystem

Diagram: VSCode Agent Tool Categories

The VSCode Agent provides 20+ tools organized into seven functional categories. Each tool is designed to integrate seamlessly with VS Code's extension API.

Sources: VSCode Agent/Prompt.txt68-381

Context Discovery Strategy

The VSCode Agent implements a three-tier search hierarchy optimized for different discovery patterns:

Search Tool Hierarchy:

1. semantic_search (Primary): Natural language queries for conceptual code discovery

   • Returns relevant code snippets from workspace
   • Returns full workspace contents if workspace is small
   • Must never be called in parallel
   • Example query: "authentication logic that validates JWT tokens"

2. grep_search (Pattern matching): Exact string or regex searches

   • Limited to 20 results
   • Supports regex via isRegexp parameter
   • Example: Finding all instances of a specific error message

3. file_search (Name-based): Glob pattern matching on file paths

   • Limited to 20 results
   • Example: **/*.{js,ts} for all JavaScript/TypeScript files

Sources: VSCode Agent/Prompt.txt19-36 VSCode Agent/Prompt.txt71-152

File Editing Workflow

Diagram: VSCode Agent File Editing Sequence

The editing workflow enforces strict validation requirements to ensure code quality.

Editing Rules:

• MANDATORY: Read file before editing (enforced by tool)
• NEVER print code blocks to user; always use insert_edit_into_file
• MANDATORY: Call get_errors after every file modification
• Use minimal code repetition with // ...existing code... comments

insert_edit_into_file Example Pattern:

Sources: VSCode Agent/Prompt.txt41-66 VSCode Agent/Prompt.txt326-346

Command Execution Model

The run_in_terminal tool provides shell command execution with special handling for background processes:

Parameters:

• command: The shell command to execute
• explanation: One-sentence description of command purpose
• isBackground: Boolean flag for long-running processes

Background Process Handling:

• Background processes return a terminal ID immediately
• Use get_terminal_output to check output of background processes
• Pager commands (git, less, man) must disable paging (e.g., git --no-pager or | cat)

Execution Constraints:

• Never run multiple terminal commands in parallel
• Chain commands with ; or && operators instead of separate calls
• Maintain consistent working directory using absolute paths

Sources: VSCode Agent/Prompt.txt190-224

Project Setup Tools

The VSCode Agent provides specialized tools for project initialization:

create_new_workspace Tool:

• Generates setup steps for any project type
• Supports TypeScript, Model Context Protocol (MCP) servers, VS Code extensions, Next.js, Vite
• Returns actionable setup instructions

get_project_setup_info Tool:

• Provides configuration for specific project types
• Supported languages: javascript, typescript, python, other
• Supported types: basic, mcp-server, vscode-extension, next-js, vite, other

install_extension Tool:

• Installs VS Code extensions programmatically
• Requires extension ID in format <publisher>.<extension>
• Only used during new workspace creation

Sources: VSCode Agent/Prompt.txt262-310

Windsurf Cascade System

AI Flow Paradigm

Windsurf Cascade operates on a revolutionary "AI Flow" paradigm, representing an autonomous operational model where the agent takes initiative in discovering context, planning, and executing tasks without constant user approval.

Core Principles:

• Autonomous decision-making within defined safety boundaries
• Proactive context gathering through parallel tool execution
• Memory persistence across sessions
• Browser preview integration for web development
• Deployment pipeline automation

Sources: Windsurf/Tools Wave 11.txt1-383

Comprehensive Tool Ecosystem

Diagram: Windsurf Cascade Tool Organization

Windsurf provides 30+ tools organized into seven major categories, with particularly strong capabilities in browser interaction and deployment automation.

Sources: Windsurf/Tools Wave 11.txt1-383

Browser Preview System

The browser preview system distinguishes Windsurf from other IDE-integrated assistants by providing deep integration with web application development:

browser_preview Tool:

• Parameters:
  • Name: 3-5 word title for the web server (e.g., "Personal Website")
  • Url: Full URL with scheme, domain, and port (e.g., http://localhost:8080)
  • toolSummary: Brief 2-5 word summary
• Does not automatically open browser; user must click provided button
• Returns page_id for subsequent operations

Browser Interaction Tools:

• open_browser_url: Navigate to URL in Windsurf Browser
• read_browser_page: Retrieve rendered page content
• capture_browser_console_logs: Extract console logs using page_id
• capture_browser_screenshot: Capture current viewport
• get_dom_tree: Retrieve DOM structure
• list_browser_pages: List all open pages with metadata (page_id, url, title, viewport size)

Sources: Windsurf/Tools Wave 11.txt1-17 Windsurf/Tools Wave 11.txt126-161 Windsurf/Tools Wave 11.txt179-193

Code Search Implementation

Diagram: Windsurf Search Strategy Decision Tree

codebase_search Tool:

• Quality Constraint: Search quality degrades substantially above 500 files
• Best for precise, purpose-related queries about function or code purpose
• Poor for broad questions about frameworks or large system components
• Returns truncated results for non-top items; use view_code_item for full content

grep_search Tool (ripgrep):

• Returns JSON format with Filename, LineNumber, LineContent
• Capped at 50 matches
• Parameters:
  • Query: Search pattern (regex if IsRegex=true)
  • SearchPath: Directory or file (required)
  • Includes: Glob patterns for file filtering
  • CaseInsensitive: Boolean flag
  • MatchPerLine: True for line matches, false for file names only

find_by_name Tool (fd):

• Smart case matching
• Ignores gitignored files by default
• Capped at 50 results
• Parameters include Pattern, Extensions, FullPath, MaxDepth, Type

Sources: Windsurf/Tools Wave 11.txt35-43 Windsurf/Tools Wave 11.txt102-124 Windsurf/Tools Wave 11.txt134-155

File Editing with ReplacementChunks

Windsurf uses a unique replace_file_content tool that supports multiple non-adjacent edits in a single call:

ReplacementChunk Structure:

Editing Rules:

1. NEVER make multiple parallel calls to replace_file_content for the same file
2. For multiple non-adjacent edits, use multiple ReplacementChunks in one call
3. TargetContent must EXACTLY match existing file content including whitespace
4. Do NOT replace entire file content; use targeted chunks
5. Cannot edit .ipynb files (use different tool)

Required Arguments Order:

1. TargetFile (must be specified first)
2. Instruction: Description of changes
3. ReplacementChunks: Array of edit operations
4. CodeMarkdownLanguage: Language identifier
5. TargetLintErrorIds: Optional lint error IDs being fixed

Sources: Windsurf/Tools Wave 11.txt231-260

Command Execution and Safety Model

Diagram: Windsurf Command Execution Flow

run_command Tool Parameters:

• CommandLine: Exact command string
• Cwd: Current working directory (optional)
• SafeToAutoRun: Boolean for automatic execution without approval
• Blocking: If true, blocks until command completes
• WaitMsBeforeAsync: Milliseconds to wait before going fully async

Safety Guidelines:

• NEVER propose cd commands (manage working directory with absolute paths)
• Commands run with PAGER=cat
• Only set SafeToAutoRun=true for commands with no destructive side-effects
• Unsafe operations: deleting files, mutating state, installing dependencies, external requests

Command Status Polling:

• command_status tool checks background command progress
• Parameters:
  • CommandId: Background command ID
  • WaitDurationSeconds: Wait time before returning status (0-60)
  • OutputCharacterCount: Number of characters to retrieve

Sources: Windsurf/Tools Wave 11.txt262-283 Windsurf/Tools Wave 11.txt46-55

Web Application Deployment Pipeline

Windsurf provides end-to-end deployment automation for JavaScript web applications:

Diagram: Windsurf Deployment Workflow

Supported Frameworks:

• eleventy, angular, astro, create-react-app, gatsby, gridsome
• grunt, hexo, hugo, hydrogen, jekyll, middleman
• mkdocs, nextjs, nuxtjs, remix, sveltekit, svelte

Deployment Parameters:

• Framework: Must match supported framework exactly
• ProjectPath: Full absolute path to project root
• ProjectId: For re-deploying to existing site (leave empty for new sites)
• Subdomain: Unique subdomain for new sites only

Deployment Process:

1. Run read_deployment_config to validate project readiness
2. Create any missing required files
3. Call deploy_web_app with appropriate parameters
4. Poll check_deploy_status using returned windsurf_deployment_id
5. Return deployment URL to user

Sources: Windsurf/Tools Wave 11.txt27-33 Windsurf/Tools Wave 11.txt88-100 Windsurf/Tools Wave 11.txt195-201

Memory and Trajectory Systems

create_memory Tool: Provides CRUD operations for persistent memory storage across sessions.

Actions:

• create: New memory with Title, Content, Tags, CorpusNames
• update: Modify existing memory using Id
• delete: Remove memory using Id

Memory Guidelines:

• Check for semantically related memories before creating duplicates
• Use snake_case for tags
• Associate with specific workspaces via CorpusNames (must exactly match system prompt values)
• Set UserTriggered=true if user explicitly requested memory operation

Memory Use Cases:

• User preferences and behavior modifications
• Important code snippets
• Technical stack documentation
• Project structure information
• Design patterns and architectural decisions

trajectory_search Tool: Semantic search across conversation history (Cascade conversations) or user activities.

Parameters:

• ID: Cascade ID for conversations
• Query: Search query (empty returns all steps)
• SearchType: cascade for conversations, user for activities
• Returns up to 50 chunks sorted by relevance

Sources: Windsurf/Tools Wave 11.txt57-86 Windsurf/Tools Wave 11.txt302-312

Amp by Sourcegraph

System Overview and Configuration

Amp is Sourcegraph's powerful AI coding agent with configurable LLM support, including specialized model routing for different task types.

Configuration:

• Access via VS Code settings: amp.url and amp.gpt5
• System prompt retrieval: Hold Alt (Windows) or Option (macOS) → Click workspace button → "View Thread YAML"
• Two prompt versions:
  • claude-4-sonnet.yaml: Default configuration tuned for Claude Sonnet 4.x
  • gpt-5.yaml: Alternative configuration for GPT-5 when amp.gpt5: true

Configuration Example:

Sources: Amp/README.md1-21

Multi-Model Architecture with Oracle

Diagram: Amp Multi-Model Architecture with Oracle Integration

Oracle Tool (o3 Reasoning Model):

• Powered by OpenAI's o3 reasoning model
• Use cases:
  • Planning complex implementations
  • Code review and architecture decisions
  • Performance analysis
  • Complex debugging scenarios
  • Trade-off analysis for major decisions

When to Use Oracle:

• "I need a senior engineer to think with me" → Oracle
• Architecture planning before implementation
• Debugging race conditions or complex failures
• Performance optimization guidance
• Design pattern recommendations

Oracle Prompting Guidelines:

• Provide precise problem description
• Attach necessary files or code
• Request concrete outcomes
• Ask for trade-off analysis
• Utilize reasoning capabilities

Sources: Amp/claude-4-sonnet.yaml211-298

Sub-agent Delegation System

Diagram: Amp Sub-agent Workflow Pattern

Task Tool:

• Purpose: Fire-and-forget executor for heavy, multi-file implementations
• Think of it as: Productive junior engineer who can't ask follow-ups once started
• Use for: Feature scaffolding, cross-layer refactors, mass migrations, boilerplate
• Don't use for: Exploratory work, architectural decisions, debugging analysis
• Prompting: Provide detailed instructions, enumerate deliverables, step-by-step procedures, validation methods, constraints, and examples

Codebase Search Agent:

• Purpose: Locate logic based on conceptual descriptions across languages/layers
• Use for: Mapping features, tracking capabilities, finding side-effects by concept
• Don't use for: Code changes, design advice, simple exact text searches
• Prompting: Describe real-world behavior, provide keywords/hints, specify file types or directories, request desired output format

Best Practices:

• Workflow: Oracle (plan) → Codebase Search (validate scope) → Task Tool (execute)
• Scope: Always constrain directories, file patterns, acceptance criteria
• Prompts: Many small, explicit requests > one giant ambiguous request

Sources: Amp/gpt-5.yaml220-287 Amp/claude-4-sonnet.yaml211-298

Tool Suite and Capabilities

Core Tools (Amp):

• Bash: Shell command execution with timeout support
• Read: File reading with absolute paths
• Edit: Exact string replacement in files
• Grep: Pattern search using ripgrep
• Glob: File pattern matching
• Mermaid: Diagram generation
• Oracle: o3 reasoning model consultation
• Task: Sub-agent delegation
• Codebase Search Agent: Conceptual code location

Specialized Features:

• Automatic AGENTS.md context loading
• Todo list management (todo_write, todo_read)
• Web search and page fetching capabilities
• Markdown formatting with fluent file linking

Sources: Amp/claude-4-sonnet.yaml1-700 Amp/gpt-5.yaml1-700

Agency and Execution Model

Role Principles (from gpt-5.yaml):

• End-to-end completion: "Do the task end to end. Don't hand back half-baked work."
• Balance initiative with restraint: If user asks for plan, give plan; don't edit files
• No explanations unless asked: After edits, stop
• Minimize reasoning: Brief 1-2 sentence summaries before tool calls only

Guardrails:

• Simple-first: Prefer smallest local fix over cross-file architecture changes
• Reuse-first: Search existing patterns; mirror naming, error handling, typing
• No surprise edits: If changes affect >3 files or multiple subsystems, show plan first
• No new dependencies without explicit user approval

Context Understanding Strategy:

1. Start broad, fan out to focused subqueries in parallel
2. Deduplicate paths and cache; don't repeat queries
3. Avoid serial per-file grep
4. Early stop if you can name exact files/symbols to change or have high-confidence bug locus

Sources: Amp/gpt-5.yaml14-60

Parallel Execution Policy

Default: Parallel for all independent work (reads, searches, diagnostics, writes, subagents)

What to Parallelize:

• Reads/Searches/Diagnostics: Independent calls
• Codebase Search agents: Different concepts/paths
• Oracle: Distinct concerns (architecture review, performance analysis, race investigation)
• Task executors: Multiple tasks iff write targets are disjoint
• Independent writes: Multiple writes iff disjoint

When to Serialize:

• Plan → Code: Planning must finish before dependent edits
• Write conflicts: Edits touching same file(s) or shared contracts (types, DB schema, API)
• Chained transforms: Step B requires artifacts from step A

Good Parallel Example:

Oracle(plan-API)
codebase_search_agent("validation flow")  
codebase_search_agent("timeout handling")
Task(add-UI)
Task(add-logs)
→ disjoint paths → parallel

Bad Example:

Task(refactor) touching api/types.ts
Task(handler-fix) also touching api/types.ts
→ must serialize

Sources: Amp/gpt-5.yaml72-121

Claude Code by Anthropic

Tool Architecture and Organization

Claude Code provides a comprehensive tool ecosystem organized into four primary categories:

Diagram: Claude Code Tool Organization

Sources: Anthropic/Claude Code/Tools.json1-390

Task Tool and Specialized Agents

The Task tool launches specialized sub-agents for complex, multi-step autonomous operations:

Available Agent Types:

1. general-purpose:

   • Tools: All tools (*)
   • Use for: Researching complex questions, searching code, executing multi-step tasks
   • Best for: When searching for keywords/files and not confident in finding right match in first few tries

2. statusline-setup:

   • Tools: Read, Edit
   • Use for: Configuring Claude Code status line settings

3. output-style-setup:

   • Tools: Read, Write, Edit, Glob, LS, Grep
   • Use for: Creating Claude Code output styles

Usage Guidelines:

When to Use Task Tool:

• Complex, multi-step tasks requiring autonomy
• Searching code when uncertain about finding matches quickly
• Multi-file implementations

When NOT to Use Task Tool:

• Reading specific file path → use Read tool
• Searching specific class definition → use Glob tool
• Searching within specific files (2-3 files) → use Read tool
• Tasks unrelated to agent descriptions

Best Practices:

1. Launch multiple agents concurrently for parallel work
2. Agent returns single message when done (not visible to user)
3. Each invocation is stateless; provide detailed task description
4. Clearly indicate if agent should write code or just research
5. Trust agent outputs
6. Use proactively if agent description mentions it

Sources: Anthropic/Claude Code/Tools.json3-30

File Editing Operations

Diagram: Claude Code File Editing Decision Tree

Edit Tool:

• Requirements: Must use Read tool at least once before editing
• Performs exact string replacement
• Edit FAILS if old_string is not unique (unless replace_all=true)
• Must preserve exact indentation from Read output (after line number prefix)
• Line number prefix format: spaces + line number + tab
• Never include line number prefix in old_string or new_string

MultiEdit Tool:

• Built on Edit tool for multiple edits to single file
• All edits applied in sequence (order matters)
• Each edit operates on result of previous edit
• All edits must be valid or none are applied (atomic operation)
• Use replace_all for renaming variables across file

Write Tool:

• Overwrites existing file or creates new file
• MANDATORY: Must use Read tool first for existing files
• PREFER EDITING: Only use when necessary
• Never proactively create documentation files unless requested

NotebookEdit Tool:

• For Jupyter notebooks (.ipynb files)
• Edit modes: replace, insert, delete
• Cell types: code, markdown
• Uses cell_id to target specific cell

Sources: Anthropic/Claude Code/Tools.json193-296 Anthropic/Claude Code/Tools.json299-365

Shell Command Execution

Bash Tool: Executes shell commands with comprehensive control over execution behavior.

Key Parameters:

• command: The command to execute (required)
• timeout: Optional timeout in milliseconds (max 600000ms / 10 minutes, default 120000ms)
• description: Clear 5-10 word description of command purpose
• run_in_background: Boolean for background execution

Important Constraints:

• NEVER use cd: Maintain working directory with absolute paths
• AVOID search commands: Never use find or grep → use Grep, Glob, or Task tools instead
• AVOID read tools: Don't use cat, head, tail, ls → use Read and LS tools
• Use ripgrep: If grep needed, use rg (pre-installed)
• Quote file paths: Always quote paths with spaces (e.g., cd "path with spaces")
• Chain commands: Use ; or && operators, NOT newlines

Background Process Management:

• Use run_in_background=true for long-running processes
• Monitor output using BashOutput tool
• Never use & operator manually
• Never use sleep in background mode

Sources: Anthropic/Claude Code/Tools.json31-60

Git Operations and Pull Requests

Git Commit Workflow:

1. Run parallel bash commands:
   • git status - see untracked files
   • git diff - see staged and unstaged changes
   • git log - see recent commit messages for style consistency
2. Analyze changes and draft commit message
3. Run parallel:
   • Add relevant untracked files to staging
   • Create commit with standardized message format
   • Run git status to verify

Commit Message Format:

[Commit message]

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Commit Message Best Practices:

• Use HEREDOC for proper formatting
• Never update git config
• Never run additional read/explore commands
• Never use TodoWrite or Task tools
• Don't push unless explicitly requested
• Never use -i flag (interactive mode not supported)
• Avoid empty commits

Pull Request Creation:

1. Run parallel bash commands:
   • git status - check untracked files
   • git diff - see staged/unstaged changes
   • Check if current branch tracks remote and is up to date
   • git log and git diff [base-branch]...HEAD - full commit history from divergence
2. Analyze ALL commits (not just latest)
3. Run parallel:
   • Create new branch if needed
   • Push to remote with -u flag if needed
   • Create PR using gh pr create with HEREDOC format

PR Body Format:

## Summary
<1-3 bullet points>

## Test plan
[Checklist of TODOs for testing...]

🤖 Generated with [Claude Code](https://claude.ai/code)

GitHub CLI Usage:

• Use gh command for ALL GitHub operations (issues, PRs, checks, releases)
• If given GitHub URL, use gh to get information
• View PR comments: gh api repos/foo/bar/pulls/123/comments

Sources: Anthropic/Claude Code/Tools.json32-60

Search and Discovery Tools

Glob Tool:

• Fast file pattern matching for any codebase size
• Supports glob patterns like **/*.js or src/**/*.ts
• Returns matching file paths sorted by modification time
• Use when pattern-based file discovery needed
• For open-ended searches requiring multiple rounds, use Task tool instead
• Always batch multiple speculative searches

Grep Tool:

• Powered by ripgrep (optimized with correct permissions)
• ALWAYS use Grep tool, NEVER invoke grep or rg as Bash command
• Full regex syntax support
• Filter files with glob parameter or type parameter
• Output modes:
  • content: Show matching lines
  • files_with_matches: Show only file paths (default)
  • count: Show match counts
• Pattern syntax: Uses ripgrep (not grep)
  • Literal braces need escaping: interface\{\} to find interface{}
• Multiline matching: Set multiline: true for cross-line patterns

LS Tool:

• Lists files and directories at given path
• Path must be absolute (not relative)
• Optional ignore parameter for glob patterns
• Generally prefer Glob and Grep tools when directories are known

Sources: Anthropic/Claude Code/Tools.json61-174

TodoWrite Task Management System

The TodoWrite tool provides structured task list management for complex work:

Tool Schema:

Usage Guidelines:

• Use for complex multi-step tasks requiring careful planning
• Create TODO before starting work to avoid forgetting important tasks
• Mark todos as completed immediately after finishing
• Do not batch multiple completions
• Break down larger tasks into smaller steps
• Give user visibility into progress

When to Use:

• Complex multi-step tasks (3+ distinct steps)
• Non-trivial tasks requiring planning
• User explicitly requests todo list
• User provides multiple tasks
• After receiving new instructions
• When starting work on a task (mark as in_progress BEFORE beginning)
• After completing a task (mark as completed)

When NOT to Use:

• Single straightforward task
• Trivial tasks with no organizational benefit
• Tasks completable in <3 trivial steps
• Purely conversational or informational tasks

Sources: Anthropic/Claude Code/Tools.json390-470 (in full Tools.json file beyond provided excerpt)

Cross-System Comparison

Tool Naming and Organization Patterns

System	Tool Prefix	Organization Strategy	Example
VSCode Agent	None	Verb-based descriptive names	semantic_search, read_file, get_errors
Windsurf	None	Verb-based with underscore separation	codebase_search, replace_file_content, run_command
Amp	None	Simple noun/verb names	Bash, Read, Edit, Grep, Oracle
Claude Code	None	Mixed case with descriptive names	Task, MultiEdit, TodoWrite, ExitPlanMode

File Editing Strategy Comparison

Diagram: File Editing Approaches Across IDE-Integrated Systems

Feature	VSCode Agent	Windsurf	Amp	Claude Code
Read Before Edit	Mandatory (enforced)	Best practice	Best practice	Mandatory (enforced)
Primary Edit Tool	insert_edit_into_file	replace_file_content	Edit	Edit / MultiEdit
Multi-edit Support	Multiple tool calls	Single call with array	Multiple calls	MultiEdit tool
Validation	Mandatory get_errors	Optional lint IDs	Via diagnostics	Via diagnostics
Comments for Ellipsis	// ...existing code...	No ellipsis pattern	No ellipsis pattern	No ellipsis pattern

Sources: VSCode Agent/Prompt.txt41-66 Windsurf/Tools Wave 11.txt231-260 Anthropic/Claude Code/Tools.json220-296

Command Execution Models

System	Tool Name	Background Support	Safety Mechanism	Output Monitoring
VSCode Agent	run_in_terminal	isBackground flag	User always approves	get_terminal_output with ID
Windsurf	run_command	Blocking flag + async	SafeToAutoRun flag	command_status with ID
Amp	Bash	run_in_background	User approval	BashOutput tool
Claude Code	Bash	run_in_background	User approval	BashOutput, KillBash

Common Constraints:

• All systems discourage or prohibit cd commands
• All systems recommend pager disabling (PAGER=cat)
• All systems support background process monitoring
• All systems emphasize absolute paths over relative paths

Sources: VSCode Agent/Prompt.txt190-224 Windsurf/Tools Wave 11.txt262-283 Anthropic/Claude Code/Tools.json32-60

Search Tool Capabilities

Diagram: Search Capabilities Across IDE-Integrated Systems

Semantic Search Comparison:

• VSCode Agent: semantic_search never in parallel, returns full workspace if small
• Windsurf: codebase_search degrades above 500 files, truncates non-top results
• Amp: Dedicated Codebase Search Agent sub-agent for conceptual searches
• Claude Code: Uses Task tool with general-purpose agent type

Pattern Search Comparison:

• All systems: Use ripgrep as underlying engine
• Result limits: VSCode (20), Windsurf (50), Amp (unspecified), Claude Code (unspecified)
• Unique features:
  • Claude Code supports multiline regex matching
  • Windsurf provides JSON output with line numbers
  • All support case-insensitive search

Sources: VSCode Agent/Prompt.txt71-152 Windsurf/Tools Wave 11.txt35-155 Anthropic/Claude Code/Tools.json61-148

Sub-agent and Delegation Patterns

System	Sub-agent Tool	Purpose	Specializations
VSCode Agent	None	N/A	No sub-agent delegation
Windsurf	trajectory_search	Access conversation history	Semantic search across past conversations
Amp	Task, Oracle, Codebase Search Agent	Parallel specialization	Task execution, reasoning, code discovery
Claude Code	Task	Launch specialized agents	general-purpose, statusline-setup, output-style-setup

Amp's Multi-agent Approach:

• Oracle: Senior engineer advisor with o3 reasoning for planning, review, debugging
• Task Tool: Junior engineer executor for multi-file implementations
• Codebase Search Agent: Conceptual code locator across languages/layers
• Workflow: Oracle (plan) → Codebase Search (validate) → Task Tool (execute)

Claude Code's Agent Types:

• general-purpose: Full tool access (*) for complex research and execution
• statusline-setup: Limited to Read, Edit for configuration
• output-style-setup: Read, Write, Edit, Glob, LS, Grep for style creation

Sources: Amp/gpt-5.yaml220-287 Anthropic/Claude Code/Tools.json3-30

Memory and Context Persistence

System	Memory Tool	Persistence Scope	Features
VSCode Agent	update_user_preferences	User preferences only	Saves corrections and coding preferences
Windsurf	create_memory, trajectory_search	Workspace-specific, cross-session	CRUD operations, tags, semantic search
Amp	AGENTS.md auto-context	Project-level	Auto-loads commands, conventions, structure
Claude Code	None explicit	N/A	Relies on conversation context

Windsurf Memory Categories:

• User preferences
• Explicit user requests to remember
• Important code snippets
• Technical stacks
• Project structure
• Major milestones/features
• Design patterns and architectural decisions

Memory Best Practices (Windsurf):

• Check for semantically related memories before creating duplicates
• Use snake_case for tags
• Associate with specific workspaces via exact CorpusNames match
• Set UserTriggered=true for explicit user requests

Sources: VSCode Agent/Prompt.txt38-39 Windsurf/Tools Wave 11.txt57-86 Amp/gpt-5.yaml300-314

Unique Capabilities Matrix

Capability	VSCode Agent	Windsurf	Amp	Claude Code
Browser Preview	❌	✅ Full integration	❌	❌
Deployment Pipeline	❌	✅ Netlify automation	❌	❌
Multi-Model Routing	❌	❌	✅ Oracle (o3) + Sonnet	❌
Project Scaffolding	✅ create_new_workspace	❌	✅ Task Tool	❌
Extension Management	✅ install_extension	❌	❌	❌
Jupyter Notebook Editing	✅ create_new_jupyter_notebook	❌	❌	✅ NotebookEdit
VS Code API Reference	✅ get_vscode_api	❌	❌	❌
Git Operations	✅ get_changed_files	❌	❌	✅ Full workflow
MCP Server Integration	❌	✅ list_resources, read_resource	❌	❌
Parallel Tool Execution	✅ (except semantic_search)	✅ parallel tool	✅ Default behavior	✅ Batching
Task List Management	❌	❌	✅ todo_write, todo_read	✅ TodoWrite

Sources: VSCode Agent/Prompt.txt1-405 Windsurf/Tools Wave 11.txt1-383 Amp/claude-4-sonnet.yaml1-700 Anthropic/Claude Code/Tools.json1-390

Implementation Patterns and Best Practices

Read-Before-Edit Enforcement

All IDE-integrated systems enforce or strongly recommend reading files before editing:

Enforcement Mechanisms:

• VSCode Agent: Tool will error without prior read
• Claude Code: "This tool will fail if you did not read the file first"
• Windsurf: Best practice recommendation
• Amp: Best practice recommendation

Rationale:

• Prevents blind overwrites
• Ensures context-aware modifications
• Enables preservation of existing code structure
• Allows detection of formatting and style conventions

Sources: VSCode Agent/Prompt.txt42 Anthropic/Claude Code/Tools.json194-217 Windsurf/Tools Wave 11.txt231-260

Parallel Execution Strategy

Diagram: Parallel vs Sequential Execution Decision Flow

Systems Supporting Parallelization:

• VSCode Agent: Explicit parallel support except for semantic_search
• Windsurf: Dedicated parallel tool with tool_uses array
• Amp: Default parallel for all independent operations
• Claude Code: Batch multiple tool calls in single response

Common Parallelizable Operations:

• Multiple file reads
• Independent search queries
• Diagnostic checks
• Writes to different files
• Sub-agent launches (Amp)

Must Serialize:

• Edits to same file
• Operations with data dependencies
• Shared contract modifications (types, schemas, APIs)

Sources: VSCode Agent/Prompt.txt35 Windsurf/Tools Wave 11.txt371-382 Amp/gpt-5.yaml72-121

Error Handling and Validation

Validation Requirements:

System	Validation Tool	When Required	Error Limit
VSCode Agent	get_errors	After every file edit (MANDATORY)	No specified limit
Windsurf	Lint error IDs in edit calls	Optional, for targeted fixes	No specified limit
Amp	get_diagnostics	After completing tasks	No specified limit
Claude Code	Diagnostics	After edits	3-attempt limit (implied)

Validation Workflow Pattern:

1. Make code modification
2. Run validation tool (get_errors, diagnostics)
3. If errors found, fix relevant errors
4. Re-validate
5. Repeat until clean or error limit reached

Sources: VSCode Agent/Prompt.txt48 Windsurf/Tools Wave 11.txt256-257 Amp/gpt-5.yaml50-57

Terminal Command Best Practices

Universal Constraints:

Diagram: Terminal Command Constraints and Requirements

Common Prohibitions:

• cd commands: All systems recommend absolute paths instead
• Background operator (&): Use background flags instead
• Interactive flags (-i): Not supported in automation
• Search commands in shell: Use dedicated search tools (Grep, Glob)

Common Requirements:

• Quote file paths containing spaces
• Disable pagers for commands that use them (git, less, man)
• Chain commands with ; or &&, not newlines
• Specify working directory explicitly

Sources: VSCode Agent/Prompt.txt191 Windsurf/Tools Wave 11.txt263 Anthropic/Claude Code/Tools.json32