gemini-cli
Use Gemini CLI for analyzing large codebases or multiple files that exceed context limits. Leverage Google Gemini's massive context window with `gemini -p` and `@` syntax for file/directory inclusion to verify implementations, check patterns, and understand project-wide architecture.
What this skill does
# Gemini CLI for Large Codebase Analysis ## What this Skill does When you need to analyze large codebases, multiple files, or entire directories that might exceed your context window, use the Gemini CLI. This tool provides access to Google Gemini's large context capacity, allowing you to: - Analyze entire codebases or large directories - Compare multiple large files simultaneously - Understand project-wide patterns or architecture - Verify if specific features, patterns, or security measures are implemented - Check for the presence of certain coding patterns across the entire codebase - Work with files totaling more than 100KB ## File and Directory Inclusion Syntax Use the `@` syntax to include files and directories in your Gemini prompts. **Important**: Paths are relative to WHERE you run the gemini command. ### Single File Analysis ```bash gemini -p "@src/main.py Explain this file's purpose and structure" ``` ### Multiple Files ```bash gemini -p "@package.json @src/index.js Analyze the dependencies used in the code" ``` ### Entire Directory ```bash gemini -p "@src/ Summarize the architecture of this codebase" ``` ### Multiple Directories ```bash gemini -p "@src/ @tests/ Analyze test coverage for the source code" ``` ### Current Directory and Subdirectories ```bash gemini -p "@./ Give me an overview of this entire project" ``` Or use the `--all_files` flag: ```bash gemini --all_files -p "Analyze the project structure and dependencies" ``` ## Implementation Verification Examples ### Check if a Feature is Implemented ```bash gemini -p "@src/ @lib/ Has dark mode been implemented in this codebase? Show me the relevant files and functions" ``` ### Verify Authentication Implementation ```bash gemini -p "@src/ @middleware/ Is JWT authentication implemented? List all auth-related endpoints and middleware" ``` ### Check for Specific Patterns ```bash gemini -p "@src/ Are there any React hooks that handle WebSocket connections? List them with file paths" ``` ### Verify Error Handling ```bash gemini -p "@src/ @api/ Is proper error handling implemented for all API endpoints? Show examples of try-catch blocks" ``` ### Check for Rate Limiting ```bash gemini -p "@backend/ @middleware/ Is rate limiting implemented for the API? Show the implementation details" ``` ### Verify Caching Strategy ```bash gemini -p "@src/ @lib/ @services/ Is Redis caching implemented? List all cache-related functions and their usage" ``` ### Check for Specific Security Measures ```bash gemini -p "@src/ @api/ Are SQL injection protections implemented? Show how user inputs are sanitized" ``` ### Verify Test Coverage for Features ```bash 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 - Always navigate to the appropriate directory before running gemini commands to ensure relative paths work correctly
Related in AI Agents
skill-development
IncludedComprehensive meta-skill for creating, managing, validating, auditing, and distributing Claude Code skills and slash commands (unified in v2.1.3+). Provides skill templates, creation workflows, validation patterns, audit checklists, naming conventions, YAML frontmatter guidance, progressive disclosure examples, and best practices lookup. Use when creating new skills, validating existing skills, auditing skill quality, understanding skill architecture, needing skill templates, learning about YAML frontmatter requirements, progressive disclosure patterns, tool restrictions (allowed-tools), skill composition, skill naming conventions, troubleshooting skill activation issues, creating custom slash commands, configuring command frontmatter, using command arguments ($ARGUMENTS, $1, $2), bash execution in commands, file references in commands, command namespacing, plugin commands, MCP slash commands, Skill tool configuration, or deciding between skills vs slash commands. Delegates to docs-management skill for official documentation.
reprompter
IncludedTransform messy prompts into well-structured, effective prompts — single or multi-agent. Use when: "reprompt", "reprompt this", "clean up this prompt", "structure my prompt", rough text needing XML tags and best practices, "reprompter teams", "repromptception", "run with quality", "smart run", "smart agents", multi-agent tasks, audits, parallel work, anything going to agent teams. Don't use when: simple Q&A, pure chat, immediate execution-only tasks. See "Don't Use When" section for details. Outputs: Structured XML/Markdown prompt, quality score (before/after), optional team brief + per-agent sub-prompts, agent team output files. Success criteria: Single mode quality score ≥ 7/10; Repromptception per-agent prompt quality score 8+/10; all required sections present, actionable and specific.
adaptive-compaction
IncludedAdaptive add-on policy and recovery layer that decides WHEN to compact, prune, snapshot, or fork -- replacing fixed-percent auto-compaction across Claude Code, Codex, and MCP-capable hosts. Trigger on auto-compact timing or damage: "when should I compact", "is it safe to compact now or start a fresh session", "auto-compact fires too early/mid-task", "switching to an unrelated task but the window still has space", "context rot", "answers get worse the longer the session runs", "the agent forgot the plan or my decisions after it summarized", "add a layer on top that manages context without changing the agent", raising autoCompactWindow to give the policy room, or installing/tuning a cross-tool compaction policy or PreCompact hook -- even when "compaction" is never said but the problem is context-window pressure or post-summarization memory loss. Do NOT use to summarize a conversation, build RAG, write a summarization prompt (decides WHEN not HOW), or answer max-context-length trivia.
agent-skill-creator
IncludedCreate cross-platform agent skills from workflow descriptions. Activates when users ask to create an agent, automate a repetitive workflow, create a custom skill, or need advanced agent creation. Triggers on phrases like create agent for, automate workflow, create skill for, every day I have to, daily I need to, turn process into agent, need to automate, create a cross-platform skill, validate this skill, export this skill, migrate this skill. Supports single skills, multi-agent suites, transcript processing, template-based creation, interactive configuration, cross-platform export, and spec validation.
llm-wiki
IncludedUse when building or maintaining a persistent personal knowledge base (second brain) in Obsidian where an LLM incrementally ingests sources, updates entity/concept pages, maintains cross-references, and keeps a synthesis current. Triggers include "second brain", "Obsidian wiki", "personal knowledge management", "ingest this paper/article/book", "build a research wiki", "compound knowledge", "Memex", or whenever the user wants knowledge to accumulate across sessions instead of being re-derived by RAG on every query.
skill-master
IncludedAgent Skills authoring, evaluation, and optimization. Create, edit, validate, benchmark, and improve skills following the agentskills.io specification. Use when designing SKILL.md files, structuring skill folders (references, scripts, assets), ingesting external documentation into skills, running trigger evals, benchmarking skill quality, optimizing descriptions, or performing blind A/B comparisons. Keywords: agentskills.io, SKILL.md, skill authoring, eval, benchmark, trigger optimization.