Deep Gemini

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

1. Model Architecture Analysis

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

1. Performance Bottleneck Analysis

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

1. Technical Debt Assessment

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

1. 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?

1. 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)

1. 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__clink
Parameters:
- cli_name: "gemini"
- prompt: "Please perform deep analysis on the following code/architecture/performance data:

  Analysis Target: [from Phase 1]
  Analysis Type: [from Phase 1]
  Key Questions: [from Phase 1]

  Please perform the following analysis:
  1. [Specific analysis dimension 1]
  2. [Specific analysis dimension 2]
  3. [Specific analysis dimension 3]
  4. Algorithm complexity assessment (time complexity, space complexity, using Big O notation)

  Provide detailed analysis results, including:
  - Core findings
  - Key insights
  - Complexity analysis (Big O)
  - Potential issues
  - Improvement recommendations"

- files: [Absolute paths of all relevant files]
- role: "default"
- continuation_id: [Not provided for first call]

What Happens (clink bridges to Gemini CLI):

1. clink receives Zen MCP request
2. clink launches gemini CLI session in WSL (via gemini command)
3. clink converts request into CLI-executable commands
4. Gemini CLI performs deep analysis inside WSL session environment
5. clink captures CLI output and metadata
6. Analysis results are returned to Main Claude
7. Session context is preserved via continuation_id

Gemini CLI's Work (inside WSL session):

• Read and comprehend all provided code/data
• Perform multi-dimensional analysis (logic, architecture, performance, security)
• Calculate algorithm complexity (time/space complexity in Big O notation)
• Identify patterns, anti-patterns, issues, opportunities
• Generate structured analysis findings with complexity metrics

Output: Comprehensive analysis findings with complexity data from gemini CLI

Phase 3: Structured Document Generation (Stage 2 - docgen)

Main Claude's Action:

Invoke docgen tool to generate structured document based on analysis results.

Step 1: Exploration Phase

Tool: mcp__zen__docgen
Parameters:
  step: |
    Explore the analysis project and create a document generation plan based on the following deep analysis results:

    Analysis Results:
    [Gemini CLI analysis results obtained from Phase 2]

    Document Requirements:
    1. Include executive summary
    2. Detailed methodology description
    3. Core findings (hierarchical, multi-dimensional)
    4. **Algorithm complexity analysis section** (Big O notation, including time and space complexity)
    5. Detailed analysis (in-depth explanation of each finding)
    6. Improvement recommendations (priority-sorted)
    7. Conclusion and next steps

    Format Requirements:
    - Markdown format
    - Use Mermaid diagrams (architecture diagrams, flowcharts, sequence diagrams)
    - Code examples with syntax highlighting
    - Complexity analysis presented in tables

  step_number: 1
  total_steps: 2
  next_step_required: true
  findings: ""
  num_files_documented: 0
  document_complexity: "medium"

Step 2+: Per-File Documentation Phase

Tool: mcp__zen__docgen
Parameters:
  step: |
    Generate structured document for analysis results, including:
    - Executive summary
    - Complexity analysis (Big O notation)
    - Mermaid diagrams
    - Code examples
    - Improvement recommendations

  step_number: 2
  total_steps: 2
  next_step_required: false

  findings: |
    [Step 1 exploration results + Gemini CLI analysis results]

  num_files_documented: 0
  document_complexity: "medium"

  continuation_id: [Inherited from Step 1]

What Happens (docgen workflow execution):

Step 1 (Exploration):

• docgen receives analysis results and document requirements
• Evaluates project structure and complexity
• Creates documentation plan
• Returns exploration findings with continuation_id

Step 2+ (Per-File Documentation):

• docgen generates structured document sections
• Includes Big O complexity analysis (key feature)
• Generates Mermaid diagrams automatically
• Formats code examples professionally
• Creates complexity metrics tables
• Returns complete document

docgen's Specialized Capabilities:

• Dual-phase workflow (exploration → documentation)
• Big O complexity analysis integration
• Structured document formatting
• Professional technical writing
• Automatic Mermaid diagram generation
• Code example formatting

Output: Complete structured technical document with complexity analysis

Phase 4: Review and Finalization

Main Claude's Action:

1. automation_mode check: [AUTOMATION_MODE: false] → Interactive (show + ask) / true → Automated (show + auto-save)

1. Present Document to User:

A) Interactive Mode (automation_mode = false): ``` Deep analysis document has been generated:

[Display document content summary]

Stats: [N] words, [N] sections, [N] diagrams, [N] examples, [N] complexity analyses Findings: [Core finding 1], [Core finding 2], [Core finding 3] Complexity: Highest O(?), Bottleneck: [Description]

Do you need adjustments or additions?

• Satisfied: Save document
• Need modifications: Please specify modification requirements

```

B) Automated Mode (automation_mode = true): ``` [Fully Automated Mode] Deep analysis document has been generated and automatically saved:

[Display document content summary]

Stats: [N] words, [N] sections, [N] diagrams, [N] examples, [N] complexity analyses Findings: [Core finding 1], [Core finding 2], [Core finding 3] Complexity: Highest O(?), Bottleneck: [Description]

[Automated Save Decision Record] Decision: Document quality meets standards, automatically saved Confidence: high Standards basis: Contains all required sections (executive summary, complexity analysis, mermaid diagrams, recommendations) Save path: docs/analysis/[analysistype]analysis_[timestamp].md

Recorded in auto_log.md ```

1. Handle Revisions (if requested):

For Analysis Revision (use clink): ``` Tool: mcp__zen__clink Parameters:

• cli_name: "gemini"
• prompt: "Please re-analyze the following aspects:

[User's modification requirements]

Please provide updated analysis results."

• continuation_id: [Inherited from Phase 2]

```

For Document Revision (use docgen): ``` Tool: mcp__zen__docgen Parameters: step: | Please make the following modifications to the document:

[User's modification requirements]

Please provide the revised complete document.

stepnumber: 3 # Continue workflow totalsteps: 3 nextsteprequired: false

findings: | [Previously generated document content + user modification requirements]

numfilesdocumented: 1 # Main document completed document_complexity: "medium"

continuation_id: [Inherited from Phase 3] ```

1. Save Final Document:

• Use Write tool to save document to specified path
• Default filename: {analysis_type}_analysis_{timestamp}.md
• User can specify custom filename and format

Output: Final document saved to file system

Phase 5: Post-Generation Actions (Optional)

Main Claude's Action (if requested by user):

1. Generate Summary:

• Extract key findings into a one-page summary
• Include complexity summary table
• Suitable for executive presentation

1. Create Presentation Slides:

• Convert document into slide deck outline
• Highlight key diagrams and complexity findings

1. Integration with Project Wiki:

• Add generated document link to PROJECTWIKI.md
• Update relevant sections with key insights and complexity metrics

Tool Parameters Reference

mcp__zen__clink Tool

Purpose: Bridge Zen MCP requests to Gemini CLI in WSL for code analysis

Key Parameters:

cli_name: "gemini"  # Launches 'gemini' command in WSL
prompt: |           # Analysis task for gemini CLI session
  [Detailed analysis instructions including complexity analysis requirements]
files:              # Absolute paths to context files
  - /absolute/path/to/file1.py
  - /absolute/path/to/file2.py
role: "default"     # Role preset for gemini CLI
continuation_id:    # Session ID to continue previous gemini CLI session

Responsibilities:

• Launch gemini CLI in WSL environment
• Convert Zen MCP requests to CLI commands
• Capture CLI output and metadata
• Maintain session continuity via continuation_id

mcp__zen__docgen Tool

Purpose: Multi-step structured document generation with complexity analysis

Key Parameters (Workflow Required):

# Required Parameters (Workflow Fields)
step: |             # Description and requirements of the current step
  [Detailed instructions for document generation]
  [Must include complexity analysis requirements]

step_number: 1      # Current step number
total_steps: 2      # Estimated total steps
next_step_required: true   # Whether next step is required

findings: |         # Accumulated findings and information
  [Previous findings + Analysis results]

# Required Parameters (docgen-specific)
num_files_documented: 0    # Number of files documented
document_complexity: "medium"  # Document complexity (low/medium/high)

# Optional Parameters
continuation_id:    # Continuation session ID

# Unsupported Parameters (will be rejected)
# prompt - Not accepted
# files - Not accepted
# model - Explicitly excluded
# temperature - Explicitly excluded
# thinking_mode - Explicitly excluded
# images - Explicitly excluded
# working_directory - Does not exist

Specialized Capabilities:

• Dual-phase workflow (exploration → per-file documentation)
• Big O complexity analysis integration
• Professional technical writing
• Automatic Mermaid diagram generation
• Code example formatting
• Structured document organization

Output:

• Complete markdown document with:
• Executive summary
• Methodology description
• Findings with evidence
• Complexity analysis section (Big O notation)
• Mermaid diagrams
• Code examples
• Recommendations
• Conclusion

Typical Tool Flow

Phase 1: Main Claude gathers context
    ↓
Phase 2: clink → Gemini CLI (analysis + complexity evaluation)
    ↓ [analysis results with complexity data]
Phase 3: docgen (dual-phase workflow)
    Step 1: Exploration
        - Evaluate project structure
        - Create documentation plan
        → Returns continuation_id
    Step 2: Per-File Documentation
        - Generate structured document
        - Include Big O complexity analysis
        - Generate Mermaid diagrams
        → Returns complete document
    ↓ [complete document]
Phase 4: Main Claude → User (review)
    ↓ [approval or revision request]
Phase 5: Save document (Mai

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [VCnoC](https://github.com/VCnoC)
- **Source:** [VCnoC/Claude-Code-Zen-mcp-Skill-Work](https://github.com/VCnoC/Claude-Code-Zen-mcp-Skill-Work)
- **License:** Apache-2.0

Install and usage instructions live in the source repository linked above.