Gemini Code Assist Agent Mode

1User Request: "Add authentication to the API"
2
3Agent Mode Process:
4┌────────────────────────────────────────────────────────────────┐
5│ 1. UNDERSTAND                                                   │
6│    ├─ Analyze codebase structure                               │
7│    ├─ Identify existing patterns                               │
8│    └─ Determine auth requirements                              │
9├────────────────────────────────────────────────────────────────┤
10│ 2. PLAN                                                         │
11│    ├─ Create step-by-step implementation plan                  │
12│    ├─ Identify files to create/modify                          │
13│    └─ Show plan to user for approval                           │
14├────────────────────────────────────────────────────────────────┤
15│ 3. EXECUTE                                                      │
16│    ├─ Create auth middleware                                   │
17│    ├─ Add route protection                                     │
18│    ├─ Create user model                                        │
19│    ├─ Add login/logout endpoints                               │
20│    └─ Update existing routes                                   │
21├────────────────────────────────────────────────────────────────┤
22│ 4. VERIFY                                                       │
23│    ├─ Run type checker                                         │
24│    ├─ Run tests                                                │
25│    └─ Highlight changes for review                             │
26└────────────────────────────────────────────────────────────────┘

1Common Agent Mode prompts:
2
3# Feature Development
4"Add pagination to the user list API"
5"Implement OAuth2 authentication with Google"
6"Create a caching layer for database queries"
7
8# Refactoring
9"Refactor this class to use the repository pattern"
10"Convert all callbacks to async/await"
11"Split this large component into smaller ones"
12
13# Testing
14"Generate comprehensive tests for the auth module"
15"Add integration tests for the payment flow"
16"Create test fixtures for the user model"
17
18# Bug Fixes
19"Fix the race condition in the order processing"
20"Debug why the form validation isn't working"
21"Resolve the memory leak in the image processor"
22
23# Documentation
24"Document all public APIs in the SDK"
25"Add JSDoc comments to the utility functions"
26"Create a README for this module"

1# Conceptual representation of workspace understanding
2
3class WorkspaceAnalyzer:
4    """Analyze workspace for Agent Mode."""
5
6    def __init__(self, workspace_path: str):
7        self.path = workspace_path
8        self.index = {}
9
10    def analyze(self) -> WorkspaceContext:
11        """Build comprehensive workspace understanding."""
12
13        # 1. Discover project structure
14        structure = self.map_directory_structure()
15
16        # 2. Identify project type
17        project_type = self.detect_project_type()
18
19        # 3. Parse key files
20        key_files = self.parse_key_files(project_type)
21
22        # 4. Build dependency graph
23        dependencies = self.analyze_dependencies()
24
25        # 5. Identify patterns
26        patterns = self.detect_patterns()
27
28        # 6. Index for search
29        self.build_search_index()
30
31        return WorkspaceContext(
32            structure=structure,
33            project_type=project_type,
34            key_files=key_files,
35            dependencies=dependencies,
36            patterns=patterns,
37        )
38
39    def detect_project_type(self) -> ProjectType:
40        """Detect the type of project."""
41        indicators = {
42            "package.json": "nodejs",
43            "requirements.txt": "python",
44            "go.mod": "go",
45            "Cargo.toml": "rust",
46            "pom.xml": "java-maven",
47            "build.gradle": "java-gradle",
48        }
49
50        for file, project_type in indicators.items():
51            if (self.path / file).exists():
52                return ProjectType(project_type)
53
54        return ProjectType("unknown")
55
56    def detect_patterns(self) -> list[Pattern]:
57        """Detect coding patterns in the project."""
58        patterns = []
59
60        # Check for common patterns
61        if self.has_pattern("src/components"):
62            patterns.append(Pattern("component-based"))
63
64        if self.has_pattern("src/controllers") and self.has_pattern("src/services"):
65            patterns.append(Pattern("layered-architecture"))
66
67        if self.has_pattern("__tests__") or self.has_pattern("tests"):
68            patterns.append(Pattern("tested"))
69
70        return patterns

1class AgentModeContext:
2    """Manage context for Agent Mode operations."""
3
4    def __init__(self, workspace: WorkspaceContext):
5        self.workspace = workspace
6        self.token_budget = 1_000_000  # Gemini's 1M context
7
8    def prepare_context(self, task: str) -> str:
9        """Prepare optimal context for task."""
10
11        context_parts = []
12        tokens_used = 0
13
14        # 1. Add task description
15        context_parts.append(f"Task: {task}")
16        tokens_used += self.estimate_tokens(task)
17
18        # 2. Add relevant files (prioritized)
19        relevant_files = self.find_relevant_files(task)
20        for file in relevant_files:
21            content = self.read_file(file)
22            file_tokens = self.estimate_tokens(content)
23
24            if tokens_used + file_tokens < self.token_budget * 0.7:
25                context_parts.append(f"\n--- {file} ---\n{content}")
26                tokens_used += file_tokens
27
28        # 3. Add project structure
29        structure = self.workspace.structure_summary()
30        context_parts.append(f"\n--- Project Structure ---\n{structure}")
31
32        # 4. Add relevant patterns
33        patterns = self.workspace.patterns
34        context_parts.append(f"\n--- Detected Patterns ---\n{patterns}")
35
36        return "\n".join(context_parts)
37
38    def find_relevant_files(self, task: str) -> list[str]:
39        """Find files relevant to the task."""
40
41        relevant = []
42
43        # Keyword matching
44        keywords = self.extract_keywords(task)
45        for file in self.workspace.files:
46            if self.file_matches_keywords(file, keywords):
47                relevant.append(file)
48
49        # Dependency analysis
50        for file in relevant.copy():
51            deps = self.workspace.dependencies.get(file, [])
52            relevant.extend(deps)
53
54        # Sort by relevance
55        return self.rank_by_relevance(relevant, task)

1Gemini Code Assist Agent Mode:
2+ Best IDE integration
3+ Largest context window
4+ Multimodal (can analyze screenshots)
5+ Google ecosystem integration
6+ Visual diff preview
7
8Claude Code:
9+ Most powerful agent capabilities
10+ Terminal flexibility
11+ Parallel tool execution
12+ Extensive tool ecosystem
13+ CLAUDE.md context engineering
14
15GitHub Copilot Workspace:
16+ Tight GitHub integration
17+ Issue to PR workflow
18+ Familiar interface
19+ Good for GitHub-centric teams
20- Limited agent autonomy

1Pattern 1: Feature Implementation
21. Open Agent Mode panel
32. Describe feature: "Add user profile page with edit capability"
43. Review generated plan
54. Approve or modify plan
65. Watch agent make changes
76. Review diff in IDE
87. Accept or request adjustments
9
10Pattern 2: Codebase Exploration
111. Open Agent Mode
122. Ask: "Explain how authentication works in this project"
133. Agent analyzes relevant files
144. Provides detailed explanation
155. Follow up with specific questions
16
17Pattern 3: Refactoring
181. Select code or describe scope
192. Request: "Refactor to use dependency injection"
203. Review proposed changes across files
214. Agent updates all affected locations
225. Run tests to verify
23
24Pattern 4: Bug Investigation
251. Describe bug: "Users report login fails after 24 hours"
262. Agent searches codebase
273. Identifies token expiration logic
284. Suggests fix with explanation
295. Implements fix across affected files