Config Claude Code to use Gemini as the token-consuming task assistant

Stop switching between tools - let Claude Code automatically route heavy analysis to Gemini while keeping your main coding workflow intact

First, install Gemini CLI and authenticate it:

npm install -g @google/gemini-cli
gemini

Now, add this to your ~/.claude/CLAUDE.md

# Using Gemini CLI for Large Codebase Analysis

When analyzing large codebases or multiple files that might exceed context limits, use the Gemini CLI with its massive
context window. Use `gemini -p` to leverage Google Gemini's large context capacity.

## File and Directory Inclusion Syntax

Use the `@` syntax to include files and directories in your Gemini prompts. The paths should be relative to WHERE you run the
gemini command:

### Examples:

**Single file analysis:**
gemini -p "@src/main.py Explain this file's purpose and structure"

**Multiple files:**
gemini -p "@package.json @src/index.js Analyze the dependencies used in the code"

**Entire directory:**
gemini -p "@src/ Summarize the architecture of this codebase"

**Multiple directories:**
gemini -p "@src/ @tests/ Analyze test coverage for the source code"

**Current directory and subdirectories:**
gemini -p "@./ Give me an overview of this entire project"

# Or use --all_files flag:
gemini --all_files -p "Analyze the project structure and dependencies"

## Implementation Verification Examples

**Check if a feature is implemented:**
gemini -p "@src/ @lib/ Has dark mode been implemented in this codebase? Show me the relevant files and functions"

**Verify authentication implementation:**
gemini -p "@src/ @middleware/ Is JWT authentication implemented? List all auth-related endpoints and middleware"

**Check for specific patterns:**
gemini -p "@src/ Are there any React hooks that handle WebSocket connections? List them with file paths"

**Verify error handling:**
gemini -p "@src/ @api/ Is proper error handling implemented for all API endpoints? Show examples of try-catch blocks"

**Check for rate limiting:**
gemini -p "@backend/ @middleware/ Is rate limiting implemented for the API? Show the implementation details"

**Verify caching strategy:**
gemini -p "@src/ @lib/ @services/ Is Redis caching implemented? List all cache-related functions and their usage"

**Check for specific security measures:**
gemini -p "@src/ @api/ Are SQL injection protections implemented? Show how user inputs are sanitized"

**Verify test coverage for features:**
gemini -p "@src/payment/ @tests/ Is the payment processing module fully tested? List all test cases"

## When to Use Gemini CLI

Use gemini -p when:
- Analyzing entire codebases or large directories
- Comparing multiple large files
- Need to understand project-wide patterns or architecture
- Current context window is insufficient for the task
- Working with files totaling more than 100KB
- Verifying if specific features, patterns, or security measures are implemented
- Checking for the presence of certain coding patterns across the entire codebase

## Important Notes

- Paths in @ syntax are relative to your current working directory when invoking gemini
- The CLI will include file contents directly in the context
- No need for --yolo flag for read-only analysis
- Gemini's context window can handle entire codebases that would overflow Claude's context
- When checking implementations, be specific about what you're looking for to get accurate results

Ok, now start new Claude Code session and try to tell it to read a large file or explicitly tell it to use Gemini to analyze a file.

> explain @large-file to me. Use Gemini.

Why use Gemini inside Claude Code?

While Claude Code excels at detailed implementation planning, Gemini's massive context window makes it unbeatable for codebase comprehension. Gemini can instantly digest entire codebases using just 1% context per query versus Claude Code's 10%, making it perfect for quick code understanding before switching to Claude Code for actual implementation work.RetryClaude can make mistakes. Please double-check responses.