/deep-gemini

name: deep-gemini
description: Deep technical documentation generation workflow using zen mcp's clink and docgen tools. First uses clink to launch gemini CLI in WSL for code analysis, then uses docgen for structured document generation with complexity analysis. Specializes in documents requiring deep understanding of code logic, model architecture, or performance bottleneck analysis. Use when user requests "use gemini for deep analysis", "generate architecture analysis document", "analyze performance bottlenecks", "deeply understand code logic", or similar deep analysis tasks. Default output is .md format.

Deep Gemini - Deep Technical Documentation Generation

Overview

This skill provides a two-stage deep analysis and documentation workflow:

**Stage 1 - Analysis (clink):** Launch gemini CLI in WSL to perform deep code/architecture/performance analysis **Stage 2 - Documentation (docgen):** Generate structured technical documents with Big O complexity analysis

All operations leverage zen-mcp's workflow tools to ensure thorough analysis and professional documentation output.

**Technical Architecture:**

• **zen-mcp clink**: Bridge tool to launch gemini CLI in WSL environment for code analysis
• **zen-mcp docgen**: WorkflowTool for multi-step structured document generation with complexity analysis
• **gemini CLI session**: Opened via `gemini` command in WSL, where deep analysis is executed
• **Main Claude Model**: Context gathering, workflow orchestration, user interaction
• **User**: Provides analysis targets, reviews final documents

**Two-Stage Workflow:**

Main Claude → clink → Gemini CLI (Analysis) → docgen → Structured Doc → User
     ↑                                                                  ↓
     └──────────────────── User Approval ──────────────────────────────┘

**Division of Responsibilities:**

**Stage 1 (Analysis via clink):**

• **Gemini CLI Session** (in WSL): Deep code/architecture/performance analysis, pattern identification
• **clink tool**: Bridges Zen MCP requests to CLI-executable commands, captures CLI output and metadata

**Stage 2 (Documentation via docgen):**

• **docgen tool**: Receives analysis results, executes multi-step document generation workflow, adds Big O complexity analysis
• **Main Claude Model**: Orchestrates both stages, manages user approvals, saves final documents

When to Use This Skill

Trigger this skill when the user requests:

• "Use gemini to deeply analyze code logic"
• "Generate architecture analysis document"
• "Analyze performance bottlenecks and generate report"
• "Deeply understand this code and generate documentation"
• "Generate model architecture analysis"
• "Use gemini for deep analysis"
• Any request requiring deep technical understanding and analysis documentation

**Distinction from simple-gemini:**

• **simple-gemini**: Standard documentation (PROJECTWIKI, README, CHANGELOG) and test code, uses clink only
• **deep-gemini**: Deep analysis documents with complexity analysis, uses clink + docgen two-stage workflow

Supported Document Types

This skill specializes in generating the following types of deep analysis documents:

1. **Code Logic Deep Dive**

• Control flow analysis
• Data flow tracing
• **Algorithm complexity analysis (Big O notation)**
• Edge case identification
• Performance characteristics

2. **Model Architecture Analysis**

• Architecture design patterns
• Component interaction diagrams
• Layer-by-layer analysis
• Design decision rationale
• **Complexity evaluation of architectural choices**

3. **Performance Bottleneck Analysis**

• Profiling report interpretation
• Hotspot identification
• **Time/space complexity analysis**
• Optimization recommendations
• Resource usage analysis

4. **Technical Debt Assessment**

• Code smell identification
• Refactoring priorities
• Risk assessment
• **Complexity debt analysis**
• Improvement roadmap

5. **Security Analysis Report**

• Vulnerability assessment
• Attack surface analysis
• Security best practice compliance
• Mitigation strategies
• **Complexity of security mechanisms**

**Output Format:**

• Default: `.md` (Markdown)
• User can specify other formats per requirements

**Key Feature - Complexity Analysis:** All generated documents include Big O complexity analysis where applicable, providing developers with clear performance characteristics of analyzed code.

Operation Mode (automation_mode - READ FROM SSOT)

automation_mode definition and constraints: See CLAUDE.md「📚 共享概念速查」

**This skill's role**: Skill Layer (read-only), read from context `[AUTOMATION_MODE: true/false]`

• `false` → Interactive: Show document, ask for approval
• `true` → Automated: Auto-save document, log to auto_log.md

Workflow: Two-Stage Deep Analysis Documentation Process

Phase 1: Analysis Scope Definition

**Main Claude's Responsibilities:**

1. **Clarify Analysis Objectives:**

• What aspect needs deep analysis? (code logic/architecture/performance/security)
• What is the specific question or problem to solve?
• What is the expected depth and breadth of analysis?
• Is complexity analysis required?

2. **Gather Target Code Context:**

• Identify files/modules/functions to analyze
• Read relevant source code using Read tool
• Collect supporting documentation (if exists)
• Gather performance data/logs (if applicable)

3. **Define Scope:**

   Analysis Target: [Specify analysis object]
   Analysis Type: [Code Logic/Architecture/Performance/Security]
   Key Questions: [Core questions to answer]
   Analysis Depth: [Surface/Medium/Deep]
   Complexity Analysis: [Yes/No]
   Relevant Files: [List all relevant file paths]

**Output:** Well-defined analysis scope and all necessary context files

Phase 2: Deep Analysis via Gemini CLI (Stage 1 - clink)

**Main Claude's Action:**

Invoke gemini CLI session via clink for deep analysis:

Tool: mcp__zen__