---
name: gemini-cli-assistant
description: Gemini CLI enables massive-scale codebase analysis with 2M token context (10x Claude). TRIGGERS: "analyze all files", "security audit 84 routes", "find patterns across", "repository-wide", "compare database patterns", "50+ files". USE FOR: architectural reviews, vulnerability scanning, translation gap detection, test coverage analysis, refactoring research. ACHIEVES: 80-90% token savings. SYNTAX: @file.ts or @**/*.tsx loads entire directories. DEFAULT: gemini-2.5-pro for critical analysis. HANDOFF: Gemini researches → saves report.md → Claude implements. NOT FOR: code changes, running tests, file writes (use Claude Edit/Write tools).
---

# Gemini CLI Assistant

## Overview

Gemini CLI provides specialized research and analysis capabilities with massive context windows (2M tokens for Pro, 1M for Flash) that complement Claude's implementation strengths. This skill enables efficient large-scale codebase analysis with 80-90% token savings compared to traditional file-by-file approaches.

**Key Capabilities:**

- 2M token context (gemini-2.5-pro) vs Claude's 200K
- Load entire codebases with @ file syntax
- Six specialized brainstorming methodologies
- Safe code execution in sandbox mode
- Repository-wide pattern detection
- Architectural analysis and planning

**Token Savings:** 80-90% reduction for large-scale analysis tasks

## Token Savings Summary

| Workflow                   | Traditional Approach | Gemini Approach | Savings | Reduction % |
| -------------------------- | -------------------- | --------------- | ------- | ----------- |
| Security audit (84 routes) | 165,000 tokens       | 2,000 tokens    | 163,000 | 99%         |
| Translation gap analysis   | 85,000 tokens        | 3,000 tokens    | 82,000  | 96%         |
| Pattern detection          | 120,000 tokens       | 5,000 tokens    | 115,000 | 96%         |
| Test coverage analysis     | 95,000 tokens        | 4,000 tokens    | 91,000  | 96%         |
| Architecture planning      | 200,000 tokens       | 10,000 tokens   | 190,000 | 95%         |
| Performance analysis       | 150,000 tokens       | 8,000 tokens    | 142,000 | 95%         |
| Documentation generation   | 180,000 tokens       | 12,000 tokens   | 168,000 | 93%         |

**Average: 95% token reduction across common operations**

## Quick Decision Tree

```
Need to accomplish task
↓
Involves analyzing 50+ files or entire directories?
├─ YES → Use Gemini CLI with @file syntax
└─ NO → How many files?
    ├─ 1-5 files → Use Claude Read tool
    ├─ 5-20 files → Use Claude Read tool with parallel calls
    └─ 20-50 files → Consider Gemini for efficiency

Task type:
├─ Research/Analysis/Planning → Gemini
├─ Code changes/edits → Claude
├─ Running tests → Claude
├─ File writes → Claude
└─ Large-scale pattern detection → Gemini
```

## When to Use Gemini CLI

### Primary Use Cases

**USE Gemini for:**

- Analyzing 50+ files or entire directories at once
- Security audits across all API routes (84+ endpoints)
- Finding patterns, inconsistencies, or vulnerabilities project-wide
- Architecture planning and design decisions
- Repository-wide refactoring research
- Generating comprehensive documentation from source
- Cross-file dependency mapping
- Translation gap analysis across 70+ pages
- Test coverage analysis and gap identification
- Database migration planning
- Performance bottleneck detection across services
- Comparative analysis (e.g., Prisma vs Supabase patterns)

**NOT for:**

- Making actual code changes (use Claude's Edit tool)
- Running tests or executing Bash commands
- Working with files under 20K tokens total
- Real-time iterative development
- Accessing specialized MCP servers (database, Stripe, testing)

**Golden Rule:**

```
Gemini = Research & Analysis (READ-HEAVY)
Claude = Implementation & Execution (WRITE-HEAVY)
```

## Core Capabilities

### 1. ask-gemini - Query with File Loading

Load files using @ syntax and analyze with Gemini's massive context:

```bash
# Single file analysis
gemini ask-gemini "@lib/auth.ts Analyze authentication security"

# Multiple files
gemini ask-gemini "@lib/auth.ts @lib/staff-session.ts Compare auth approaches"

# Entire directory
gemini ask-gemini "@lib/services Analyze all service modules"

# Glob patterns (MOST POWERFUL)
gemini ask-gemini "@app/api/**/route.ts Audit all 84 API routes for security"
gemini ask-gemini "@**/*.test.ts Analyze test coverage patterns"
gemini ask-gemini "@mawidi-site/**/*.tsx Find missing i18n translations"
```

### 2. Model Selection (--model flag)

**gemini-2.5-pro (DEFAULT - RECOMMENDED):**

- Use for: Security audits, architecture design, critical analysis
- Context: 2M tokens
- Quality: Highest reasoning capability
- Speed: 3-8 seconds

**gemini-2.5-flash:**

- Use for: Quick lookups, simple pattern matching, non-critical analysis
- Context: 1M tokens
- Quality: Good, less nuanced
- Speed: 1-3 seconds

**gemini-2.5-flash-8b:**

- Use for: File counting, basic syntax checks, high-volume tasks
- Context: 1M tokens
- Quality: Basic
- Speed: <1 second

### 3. Sandbox Mode (--sandbox flag)

Execute code safely in isolated environment:

```bash
# Test algorithm
gemini ask-gemini "Write function to validate Saudi phone numbers and test" --sandbox

# Data transformation
gemini ask-gemini "Parse JSON and convert to CSV" --sandbox

# Regex validation
gemini ask-gemini "Create regex for GCC phone numbers, test all formats" --sandbox
```

**Limitations:** No file system, network, or database access

### 4. Brainstorming Methodologies

Six specialized approaches for structured ideation:

```bash
# Generate many ideas
gemini brainstorm divergent "Improve appointment booking UX"

# Choose best option
gemini brainstorm convergent "Select best authentication method"

# Improve existing feature
gemini brainstorm scamper "Enhance dashboard widgets"

# User-centered design
gemini brainstorm design-thinking "Redesign onboarding flow"

# Creative breakthrough
gemini brainstorm lateral "Reduce appointment no-shows"

# Let AI choose
gemini brainstorm auto "Optimize support ticket system"
```

### 5. Output Redirection

Save results for Claude implementation:

```bash
# Save for later
gemini ask-gemini "@app/api/**/*.ts Security audit" > security-report.md

# Append to file
gemini ask-gemini "@lib/**/*.ts Find patterns" >> analysis.md
```

### 6. Help Commands

```bash
gemini Help      # Show all commands
gemini ping      # Test connection
```

## Workflows

### Workflow 1: Security Audit (80-90% Token Savings)

**Scenario:** Audit all 84 API routes for security issues

**Step 1: Gemini Analysis (Research)**

```bash
cd /Users/Asim/Desktop/mawidi_codex/mawidi-site

gemini ask-gemini "\
@app/api/**/route.ts \
@lib/auth.ts \
@lib/staff-session.ts \
Audit all API routes for:
1. Missing authentication
2. Missing rate limiting
3. SQL injection risks
4. CSRF vulnerabilities
5. Input validation gaps
Generate report with file:line references" \
--model gemini-2.5-pro > security-audit.md
```

**Step 2: Claude Implementation**

```bash
# Claude loads compact report (2K tokens) vs loading 84 files (165K tokens)
claude "Fix all security issues in security-audit.md following lib/auth.ts patterns"
```

**Token Savings:** 165K → 2K = 89% reduction

### Workflow 2: Architecture Planning

**Scenario:** Plan database migration from Prisma-only to dual-database

**Step 1: Analyze Current State**

```bash
gemini ask-gemini "\
@lib/db.ts \
@app/api/**/*.ts \
List all database operations and categorize by complexity" \
--model gemini-2.5-pro > db-operations.md
```

**Step 2: Brainstorm Approaches**

```bash
gemini brainstorm divergent "Strategies for migrating to dual-database without downtime" \
> migration-strategies.md
```

**Step 3: Select Best Approach**

```bash
gemini brainstorm convergent "$(cat migration-strategies.md) - Rank by safety and downtime" \
> migration-plan.md
```

**Step 4: Create Detailed Plan**

```bash
gemini ask-gemini "\
@lib/db.ts \
@lib/supabase.ts \
@lib/dual-database.ts \
Using migration-plan.md approach, create step-by-step migration plan with rollback procedures" \
--model gemini-2.5-pro > migration-detailed.md
```

**Step 5: Claude Executes**

```bash
claude "Execute migration-detailed.md using dual-database patterns"
```

### Workflow 3: Pattern Detection

**Scenario:** Find repeated code patterns for refactoring

**Step 1: Find Patterns**

```bash
gemini ask-gemini "\
@app/api/**/route.ts \
Identify repeated patterns to extract into utilities:
- Error handling
- Response formatting
- Validation patterns
- Database operations
List with frequency count" \
--model gemini-2.5-pro > code-patterns.md
```

**Step 2: Prioritize**

```bash
gemini brainstorm convergent "$(cat code-patterns.md) - Rank by refactoring impact" \
> refactor-priority.md
```

**Step 3: Design Utilities**

```bash
gemini ask-gemini "\
Based on refactor-priority.md, design utility functions for top 5 patterns.
Include signatures, types, usage examples" \
--model gemini-2.5-pro > utility-design.md
```

**Step 4: Claude Implements**

```bash
claude "Create utilities from utility-design.md in lib/utils/"
claude "Replace pattern instances with new utilities"
```

### Workflow 4: Translation Gap Analysis

**Scenario:** Find missing Arabic/English translations across 70+ pages

```bash
gemini ask-gemini "\
@app/**/*.tsx \
@lib/config/translations/**/*.ts \
Find all UI text and check for Arabic/English translations.
Report missing translations with file:line references" \
--model gemini-2.5-pro > translation-gaps.md

# Claude fixes
claude "Add missing translations from translation-gaps.md"
```

### Workflow 5: Test Coverage Analysis

**Scenario:** Identify untested API routes

```bash
gemini ask-gemini "\
@app/api/**/route.ts \
@__tests__/**/*.test.ts \
Identify API routes without test coverage.
List endpoints missing tests with file paths" \
--model gemini-2.5-pro > test-gaps.md

# Claude writes tests
claude "Write Jest tests for endpoints in test-gaps.md"
```

### Workflow 6: Performance Analysis

**Scenario:** Find performance bottlenecks across services

```bash
gemini ask-gemini "\
@app/api/**/route.ts \
@lib/services/**/*.ts \
Identify performance bottlenecks:
1. N+1 query patterns
2. Missing indexes
3. Large data transfers
4. Synchronous operations that could be async
5. Missing caching opportunities" \
--model gemini-2.5-pro > performance-issues.md

gemini brainstorm convergent "$(cat performance-issues.md) - Rank by impact" \
> performance-priority.md

# Claude optimizes
claude "Fix top 10 performance issues from performance-priority.md"
```

### Workflow 7: Documentation Generation

**Scenario:** Generate API docs for all 84 routes

```bash
gemini ask-gemini "\
@app/api/**/route.ts \
Generate OpenAPI 3.0 documentation including:
- Endpoint paths
- HTTP methods
- Request/response schemas
- Authentication requirements
- Rate limits" \
--model gemini-2.5-pro > openapi.json

# Validate
gemini ask-gemini "Validate this OpenAPI JSON: $(cat openapi.json)" \
--sandbox --model gemini-2.5-flash

# Claude converts to markdown
claude "Convert openapi.json to user-friendly docs/api-reference.md"
```

## Model Selection Strategy

### Decision Tree

```
Is task mission-critical or security-related?
├─ YES → gemini-2.5-pro
└─ NO → Does it require deep reasoning?
    ├─ YES → gemini-2.5-pro
    └─ NO → Is it a simple lookup/count?
        ├─ YES → gemini-2.5-flash-8b
        └─ NO → gemini-2.5-flash
```

### Model Comparison

| Task Type             | gemini-2.5-pro | gemini-2.5-flash | gemini-2.5-flash-8b |
| --------------------- | -------------- | ---------------- | ------------------- |
| Security audit        | ⭐⭐⭐⭐⭐     | ⭐⭐⭐           | ⭐⭐                |
| Architecture planning | ⭐⭐⭐⭐⭐     | ⭐⭐⭐           | ⭐                  |
| Pattern detection     | ⭐⭐⭐⭐⭐     | ⭐⭐⭐⭐         | ⭐⭐                |
| File counting         | ⭐⭐⭐         | ⭐⭐⭐⭐⭐       | ⭐⭐⭐⭐⭐          |
| Quick lookups         | ⭐⭐⭐         | ⭐⭐⭐⭐⭐       | ⭐⭐⭐⭐            |

**Mawidi Default:** Use **gemini-2.5-pro** for all production analysis tasks

## @ File Syntax Quick Reference

### Basic Patterns

```bash
# Single file
@lib/auth.ts

# Multiple specific files
@lib/auth.ts @lib/db.ts @lib/stripe.ts

# Directory (all files)
@lib/services

# Glob - all TypeScript
@**/*.ts

# Glob - all tests
@**/*.test.ts

# Glob - all API routes
@app/api/**/route.ts

# Glob - all React components
@app/**/*.tsx

# Nested path
@app/api/auth/**/*.ts
```

### Advanced Patterns

```bash
# Multi-layer analysis
gemini ask-gemini "\
@app/api/auth/**/*.ts \
@lib/auth.ts \
@lib/staff-session.ts \
Map complete authentication architecture" --model gemini-2.5-pro

# Cross-concern analysis
gemini ask-gemini "\
@app/api/**/route.ts \
@lib/services/**/*.ts \
Identify all external API calls" --model gemini-2.5-pro

# Exclude pattern (if supported)
@**/*.ts !**/*.test.ts
```

### Progressive Disclosure

Start narrow, expand if needed:

```bash
# Phase 1: High-level (flash-8b, <1s)
gemini ask-gemini "@app/api List all route categories" --model gemini-2.5-flash-8b

# Phase 2: Category analysis (flash, 2s)
gemini ask-gemini "@app/api/auth/**/*.ts List auth endpoints" --model gemini-2.5-flash

# Phase 3: Deep analysis (pro, 5s)
gemini ask-gemini "@app/api/auth/**/*.ts Audit authentication security" --model gemini-2.5-pro
```

## Brainstorming Quick Reference

| Goal                  | Method          | Output                   |
| --------------------- | --------------- | ------------------------ |
| Generate many ideas   | divergent       | 20-50 diverse ideas      |
| Choose best option    | convergent      | Ranked list, top 3-5     |
| Improve existing      | scamper         | 7-dimension analysis     |
| User-centered design  | design-thinking | 5-stage process          |
| Creative breakthrough | lateral         | Unconventional solutions |
| Let AI decide         | auto            | Optimal method           |

**Workflow Pattern:**

1. divergent → Generate ideas
2. convergent → Select best
3. scamper → Refine chosen approach

## Examples for Mawidi Project

### Example 1: Audit All Authentication

```bash
gemini ask-gemini "\
@app/api/**/route.ts \
@lib/auth.ts \
Find all routes missing authentication checks" \
--model gemini-2.5-pro > auth-gaps.md
```

### Example 2: Analyze Service Dependencies

```bash
gemini ask-gemini "\
@lib/services/**/*.ts \
Map dependencies between service modules" \
--model gemini-2.5-pro > service-map.md
```

### Example 3: Find Translation Gaps

```bash
gemini ask-gemini "\
@app/**/*.tsx \
@lib/config/translations \
Find UI text missing Arabic translations" \
--model gemini-2.5-pro > translation-gaps.md
```

### Example 4: Stripe Integration Review

```bash
gemini ask-gemini "\
@lib/stripe.ts \
@app/api/stripe/**/*.ts \
Review payment flow for security and error handling" \
--model gemini-2.5-pro > stripe-review.md
```

### Example 5: Test Coverage Report

```bash
gemini ask-gemini "\
@__tests__ \
Summarize test coverage by module" \
--model gemini-2.5-flash > test-report.md
```

### Example 6: Database Pattern Analysis

```bash
gemini ask-gemini "\
@lib/db.ts \
@lib/supabase.ts \
@lib/dual-database.ts \
Compare database access patterns" \
--model gemini-2.5-pro > db-patterns.md
```

### Example 7: Count All Resources

```bash
# Fast count
gemini ask-gemini "\
@mawidi-site/**/*.ts \
@mawidi-site/**/*.tsx \
Count: files, components, API routes, tests" \
--model gemini-2.5-flash-8b
```

## Integration with Claude

### The Golden Handoff Pattern

**Pattern:** Gemini (Research) → Claude (Implementation)

```bash
# GEMINI: Load massive context, analyze, generate plan
gemini ask-gemini "@massive/codebase/**/*.ts Analyze and create plan" \
--model gemini-2.5-pro > plan.md

# CLAUDE: Load compact plan, implement changes
claude "Execute plan.md following Mawidi patterns"
```

### Information Density Optimization

**Good Handoff Format (Compact Summary):**

```markdown
# Security Issues Found (7)

## Missing Auth Routes

1. /api/support/tickets GET - app/api/support/tickets/route.ts:15
2. /api/user/preferences POST - app/api/user/preferences/route.ts:22

## Recommended Fix

Import: import { auth } from '@/lib/auth';
Pattern: See lib/auth.ts lines 45-60
```

**Bad Handoff Format (Too Verbose):**

```markdown
# Comprehensive Authentication Audit Report

## Executive Summary

After analyzing 84 API routes across 12 directories...
[500 lines of detailed analysis that wastes Claude's tokens]
```

### Reverse Handoff (Claude → Gemini)

When Claude creates many files, use Gemini to validate:

```bash
# CLAUDE: Implement feature
claude "Implement support ticket system"

# GEMINI: Validate implementation
gemini ask-gemini "\
@app/api/support/**/*.ts \
@lib/services/support/**/*.ts \
Audit for: security, error handling, consistency" \
--model gemini-2.5-pro > implementation-review.md
```

## Token Optimization Strategies

### The 80-90% Savings Principle

**Before (Claude - Inefficient):**

```
Load file 1 → 5K tokens
Load file 2 → 5K tokens
...
Load file 50 → 5K tokens
Total: 250K tokens
```

**After (Gemini - Efficient):**

```bash
gemini ask-gemini "@lib/**/*.ts Analyze patterns" --model gemini-2.5-pro
# Loads all 50 files at once: 25K tokens
# Savings: 90%
```

### Context Window Capacity

**Gemini Pro (2M tokens) can hold:**

- ~500 TypeScript files (average 4K each)
- Entire Mawidi codebase (70+ pages, 84 routes, 100+ components)
- 10+ large repositories simultaneously

**Strategy:**

```bash
# Load ENTIRE codebase for holistic analysis
gemini ask-gemini "\
@mawidi-site/app/**/*.tsx \
@mawidi-site/lib/**/*.ts \
@mawidi-site/app/api/**/*.ts \
Generate complete architecture diagram" --model gemini-2.5-pro
```

### Batch Analysis Pattern

Instead of iterative file reading:

```bash
# One query for comprehensive analysis
gemini ask-gemini "@lib/{auth,db,stripe,email,dual-database}.ts \
Compare error handling patterns" --model gemini-2.5-pro > patterns.md

# Claude loads compact report
claude "Standardize error handling based on patterns.md"
```

## Quick Reference

### Command Templates

```bash
# Basic query
gemini ask-gemini "Your question"

# With file loading
gemini ask-gemini "@path/to/file.ts Your question"

# With model selection
gemini ask-gemini "@file.ts Question" --model gemini-2.5-pro

# With sandbox
gemini ask-gemini "Code to test" --sandbox

# Brainstorming
gemini brainstorm <method> "Topic"

# Output redirection
gemini ask-gemini "..." > output.md
gemini ask-gemini "..." >> append.md
```

### Mawidi Project Shortcuts

```bash
# Security audit
gemini ask-gemini "@mawidi-site/app/api/**/route.ts Security audit" --model gemini-2.5-pro

# Translation gaps
gemini ask-gemini "@mawidi-site/app/**/*.tsx @mawidi-site/lib/config/translations Find missing translations" --model gemini-2.5-pro

# Auth review
gemini ask-gemini "@mawidi-site/lib/auth.ts @mawidi-site/lib/staff-session.ts Review patterns" --model gemini-2.5-pro

# Service analysis
gemini ask-gemini "@mawidi-site/lib/services/**/*.ts Map dependencies" --model gemini-2.5-pro

# Test coverage
gemini ask-gemini "@mawidi-site/__tests__ Summarize coverage" --model gemini-2.5-flash

# Database comparison
gemini ask-gemini "@mawidi-site/lib/db.ts @mawidi-site/lib/supabase.ts Compare approaches" --model gemini-2.5-pro

# Stripe review
gemini ask-gemini "@mawidi-site/lib/stripe.ts @mawidi-site/app/api/stripe/**/*.ts Review payment flow" --model gemini-2.5-pro
```

### Common Use Cases

| Use Case          | Command Template                                                                      |
| ----------------- | ------------------------------------------------------------------------------------- |
| Security audit    | `gemini ask-gemini "@app/api/**/*.ts Audit security" --model gemini-2.5-pro`          |
| Find TODOs        | `gemini ask-gemini "@**/*.ts Find TODO comments" --model gemini-2.5-flash`            |
| Count files       | `gemini ask-gemini "@**/*.test.ts Count files" --model gemini-2.5-flash-8b`           |
| Generate docs     | `gemini ask-gemini "@app/api/**/*.ts Generate docs" --model gemini-2.5-pro`           |
| Pattern detection | `gemini ask-gemini "@**/*.ts Find repeated patterns" --model gemini-2.5-pro`          |
| Test coverage     | `gemini ask-gemini "@app/api/**/*.ts @**/*.test.ts Find gaps" --model gemini-2.5-pro` |
| Architecture map  | `gemini ask-gemini "@lib @app Describe architecture" --model gemini-2.5-pro`          |

## Best Practices

### DO:

- ✅ Use Gemini for 50+ file analysis
- ✅ Default to gemini-2.5-pro for critical tasks
- ✅ Use @ file syntax for efficient loading
- ✅ Save Gemini output for Claude implementation
- ✅ Use progressive disclosure (start narrow, expand)
- ✅ Combine multiple @ patterns in one query
- ✅ Redirect output to files with >
- ✅ Use brainstorming for planning phases

### DON'T:

- ❌ Don't use Gemini for code editing (use Claude)
- ❌ Don't load unnecessary files (wastes tokens)
- ❌ Don't use Gemini for running tests (use Claude)
- ❌ Don't over-use flash-8b for complex analysis
- ❌ Don't forget to sync working directory (cd to project root)
- ❌ Don't use sandbox for file/network operations
- ❌ Don't use Claude for massive context analysis (use Gemini)

## Common Pitfalls

### Pitfall 1: Using Gemini for Implementation

**WRONG:** `gemini ask-gemini "@lib/auth.ts Add rate limiting"`

**RIGHT:**

```bash
gemini ask-gemini "@lib/auth.ts Suggest where to add rate limiting" > plan.md
claude "Implement plan.md"
```

### Pitfall 2: Wrong Model for Task

**WRONG:** `gemini ask-gemini "@lib/auth.ts Security audit" --model gemini-2.5-flash-8b`

**RIGHT:** `gemini ask-gemini "@lib/auth.ts Security audit" --model gemini-2.5-pro`

### Pitfall 3: Not Saving Results

**WRONG:** Long Gemini output lost, need to regenerate

**RIGHT:** `gemini ask-gemini "..." --model gemini-2.5-pro > report.md`

### Pitfall 4: Loading Too Many Files for Simple Task

**WRONG:** `gemini ask-gemini "@mawidi-site/** Count TS files" --model gemini-2.5-pro`

**RIGHT:** `gemini ask-gemini "@**/*.ts Count files" --model gemini-2.5-flash-8b`

## Summary

### Core Principles

1. **Use Gemini for RESEARCH** - Large-scale analysis, planning, pattern detection
2. **Use Claude for IMPLEMENTATION** - Code editing, testing, execution
3. **Default to gemini-2.5-pro** - Best reasoning for critical analysis
4. **Use @ file syntax** - Load entire codebases efficiently
5. **Save results** - Redirect to files for Claude handoff
6. **Optimize tokens** - 80-90% savings vs traditional approaches
7. **Progressive disclosure** - Start narrow, expand if needed
8. **Brainstorm strategically** - Right methodology for right problem

### The Golden Workflow

```bash
# 1. GEMINI: Research & Plan (2M tokens context)
gemini ask-gemini "@massive/codebase/**/*.ts Analyze and create plan" \
--model gemini-2.5-pro > plan.md

# 2. CLAUDE: Implement & Test (2K tokens context)
claude "Execute plan.md following Mawidi patterns"

# Result: 99.9% token savings (2M → 2K)
```

### Decision Guide

**Choose Gemini if:**

- Analyzing 50+ files
- Planning architecture
- Finding patterns
- Generating reports
- Brainstorming solutions
- Security auditing

**Choose Claude if:**

- Making code changes
- Running tests
- Executing commands
- Using MCP servers
- Iterative development
- Need real-time feedback

## See Also

- [gemini-cli-best-practices.md](../../../gemini-cli-best-practices.md) - Comprehensive guide
- [api-development](../api-development/SKILL.md) - API patterns for Gemini analysis
- [database-migration](../database-migration/SKILL.md) - Database planning with Gemini
- [testing-patterns](../testing-patterns/SKILL.md) - Test gap analysis
