Advanced Context Usage Patterns

Sophisticated combinations of commands, agents, and flags for experienced GemBoost users working on complex projects.

Remember

GemBoost provides context to Gemini Cli. All patterns here are about guiding Gemini's behavior through context, not executing code or coordinating processes.

Context Combination Patterns

• Multi-Agent Context Patterns - Combining multiple specialist contexts
• Command Sequencing Patterns - Effective command combinations
• Flag Combination Strategies - Advanced flag usage

Workflow Patterns

• Complex Project Patterns - Large project approaches
• Migration Patterns - Legacy system modernization
• Review and Audit Patterns - Comprehensive analysis

Multi-Agent Context Patterns

Combining Specialist Contexts

Security + Backend Pattern

# Security-focused backend development
@agent-security "define authentication requirements"
@agent-backend-architect "design API with security requirements"
/gb:implement "secure API endpoints"

# What happens:
# 1. Security context loaded first
# 2. Backend context added
# 3. Implementation guided by both contexts
# Note: Contexts combine in Gemini's understanding, not in execution

Frontend + UX + Accessibility Pattern

# Comprehensive frontend development
@agent-frontend-architect "design component architecture"
/gb:implement "accessible React components" --magic
@agent-quality-engineer "review accessibility compliance"

# Context layering:
# - Frontend patterns guide structure
# - Magic MCP may provide UI components (if configured)
# - Quality context ensures standards

Manual vs Automatic Agent Selection

Explicit Control Pattern

# Manually control which contexts load
@agent-python-expert "implement data pipeline"
# Only Python context, no auto-activation

# vs Automatic selection
/gb:implement "Python data pipeline"
# May activate multiple agents based on keywords

Override Auto-Selection

# Prevent unwanted agent activation
/gb:implement "simple utility" --no-mcp
@agent-backend-architect "keep it simple"
# Limits context to specified agent only

Command Sequencing Patterns

Progressive Refinement Pattern

# Start broad, then focus
/gb:analyze project/
# General analysis

/gb:analyze project/core/ --focus architecture
# Focused on structure

/gb:analyze project/core/auth/ --focus security --think-hard
# Deep security analysis

# Each command builds on previous context within the conversation

Discovery to Implementation Pattern

# Complete feature development flow
/gb:brainstorm "feature idea"
# Explores requirements

/gb:design "feature architecture"
# Creates structure

@agent-backend-architect "review design"
# Expert review

/gb:implement "feature based on design"
# Implementation follows design

/gb:test --validate
# Verification approach

Iterative Improvement Pattern

# Multiple improvement passes
/gb:analyze code/ --focus quality
# Identify issues

/gb:improve code/ --fix
# First improvement pass

@agent-refactoring-expert "suggest further improvements"
# Expert suggestions

/gb:improve code/ --fix --focus maintainability
# Refined improvements

Flag Combination Strategies

Analysis Depth Control

# Quick overview
/gb:analyze . --overview --uc
# Fast, compressed output

# Standard analysis
/gb:analyze . --think
# Structured thinking

# Deep analysis
/gb:analyze . --think-hard --verbose
# Comprehensive analysis

# Maximum depth (use sparingly)
/gb:analyze . --ultrathink
# Exhaustive analysis

MCP Server Selection

# Selective MCP usage
/gb:implement "React component" --magic --c7
# Only Magic and Context7 MCP

# Disable all MCP
/gb:implement "simple function" --no-mcp
# Pure Gemini context only

# All available MCP
/gb:analyze complex-system/ --all-mcp
# Maximum tool availability (if configured)

Complex Project Patterns

Large Codebase Analysis

# Systematic exploration of large projects
# Step 1: Structure understanding
/gb:load project/
/gb:analyze . --overview --focus architecture

# Step 2: Identify problem areas
@agent-quality-engineer "identify high-risk modules"

# Step 3: Deep dive into specific areas
/gb:analyze high-risk-module/ --think-hard --focus quality

# Step 4: Implementation plan
/gb:workflow "improvement plan based on analysis"

Multi-Module Development

# Developing interconnected modules
# Frontend module
/gb:implement "user interface module"
@agent-frontend-architect "ensure consistency"

# Backend module
/gb:implement "API module"
@agent-backend-architect "ensure compatibility"

# Integration layer
/gb:implement "frontend-backend integration"
# Context from both previous implementations guides this

Cross-Technology Projects

# Projects with multiple technologies
# Python backend
@agent-python-expert "implement FastAPI backend"

# React frontend
@agent-frontend-architect "implement React frontend"

# DevOps setup
@agent-devops-architect "create deployment configuration"

# Integration documentation
/gb:document --type integration

Migration Patterns

Legacy System Analysis

# Understanding legacy systems
/gb:load legacy-system/
/gb:analyze . --focus architecture --verbose

@agent-refactoring-expert "identify modernization opportunities"
@agent-system-architect "propose migration strategy"

/gb:workflow "create migration plan"

Incremental Migration

# Step-by-step migration approach
# Phase 1: Analysis
/gb:analyze legacy-module/ --comprehensive

# Phase 2: Design new architecture
@agent-system-architect "design modern replacement"

# Phase 3: Implementation
/gb:implement "modern module with compatibility layer"

# Phase 4: Validation
/gb:test --focus compatibility

Review and Audit Patterns

Security Audit Pattern

# Comprehensive security review
/gb:analyze . --focus security --think-hard
@agent-security "review authentication and authorization"
@agent-security "check for OWASP vulnerabilities"
/gb:document --type security-audit

Code Quality Review

# Multi-aspect quality review
/gb:analyze src/ --focus quality
@agent-quality-engineer "review test coverage"
@agent-refactoring-expert "identify code smells"
/gb:improve --fix --preview

Architecture Review

# System architecture assessment
@agent-system-architect "review current architecture"
/gb:analyze . --focus architecture --think-hard
@agent-performance-engineer "identify bottlenecks"
/gb:design "optimization recommendations"

Important Clarifications

What These Patterns Actually Do

✅Guide Gemini's Thinking: Provide structured approaches
✅Combine Contexts: Layer multiple expertise areas
✅Improve Output Quality: Better code generation through better context
✅Structure Workflows: Organize complex tasks

What These Patterns Don't Do

❌Execute in Parallel: Everything is sequential context loading
❌Coordinate Processes: No actual process coordination
❌Optimize Performance: No code runs, so no performance impact
❌Persist Between Sessions: Each conversation is independent

Best Practices for Advanced Usage

Context Management

Layer Deliberately: Add contexts in logical order
Avoid Overload: Too many agents can dilute focus
Use Manual Control: Override auto-activation when needed
Maintain Conversation Flow: Keep related work in same conversation

Command Efficiency

Progress Logically: Broad → Specific → Implementation
Reuse Context: Later commands benefit from earlier context
Document Decisions: Use /gb:save for important summaries
Scope Appropriately: Focus on manageable chunks

Flag Usage

Match Task Complexity: Simple tasks don't need --ultrathink
Control Output: Use --uc for concise results
Manage MCP: Only activate needed servers
Avoid Conflicts: Don't use contradictory flags

Summary

Advanced GemBoost patterns are about sophisticated context management and command sequencing. They help Gemini Cli generate better outputs by providing richer, more structured context. Remember: all "coordination" and "optimization" happens in how Gemini interprets the context, not in any actual execution or parallel processing.

Advanced Patterns