pipeline

Research → Summarize

```bash

# Research a topic then summarize

RESEARCH=$(gemini -m pro -o text -e "" "Research: [topic]. Be comprehensive.")

SUMMARY=$(echo "$RESEARCH" | gemini -m pro -o text -e "" "Summarize this research in 5 bullet points")

echo "$SUMMARY"

```

Code → Review → Fix

```bash

# Read code, get review, apply fixes

CODE=$(cat src/module.ts)

REVIEW=$(echo "$CODE" | gemini -m pro -o text -e "" "Review this code for issues")

FIXES=$(echo "$CODE\n\nReview:\n$REVIEW" | gemini -m pro -o text -e "" "Provide fixed code")

```

Multi-Agent Pipeline

```bash

# Get perspectives from multiple agents

QUESTION="Best approach for state management in React?"

CLAUDE=$(claude --print "$QUESTION" 2>/dev/null)

GEMINI=$(gemini -m pro -o text -e "" "$QUESTION")

SYNTHESIS=$(gemini -m pro -o text -e "" "Synthesize these perspectives:

Claude: $CLAUDE

Gemini: $GEMINI

Provide a unified recommendation.")

```

Transform Chain

```bash

#!/bin/bash

# transform.sh - Chain of transformations

INPUT=$1

# Step 1: Extract

EXTRACTED=$(echo "$INPUT" | gemini -m pro -o text -e "" "Extract key points")

# Step 2: Structure

STRUCTURED=$(echo "$EXTRACTED" | gemini -m pro -o text -e "" "Organize as JSON")

# Step 3: Validate

VALIDATED=$(echo "$STRUCTURED" | gemini -m pro -o text -e "" "Validate and fix any JSON issues")

echo "$VALIDATED"

```

Conditional Pipeline

```bash

#!/bin/bash

# conditional.sh - Branch based on analysis

INPUT=$1

# Analyze type

TYPE=$(echo "$INPUT" | gemini -m pro -o text -e "" "Is this a bug report, feature request, or question? Answer with one word.")

case $TYPE in

bug*)

gemini -m pro -o text -e "" "Analyze this bug report and suggest debugging steps: $INPUT"

;;

feature*)

gemini -m pro -o text -e "" "Break down this feature request into tasks: $INPUT"

;;

question*)

gemini -m pro -o text -e "" "Answer this question: $INPUT"

;;

esac

```

Parallel Pipeline

```bash

#!/bin/bash

# parallel.sh - Run analysis in parallel

INPUT=$1

# Run in parallel

echo "$INPUT" | gemini -m pro -o text -e "" "Technical analysis" > /tmp/technical.txt &

echo "$INPUT" | gemini -m pro -o text -e "" "Business analysis" > /tmp/business.txt &

echo "$INPUT" | gemini -m pro -o text -e "" "Risk analysis" > /tmp/risk.txt &

wait

# Combine results

gemini -m pro -o text -e "" "Combine these analyses:

Technical:

$(cat /tmp/technical.txt)

Business:

$(cat /tmp/business.txt)

Risk:

$(cat /tmp/risk.txt)

Provide integrated recommendation."

```

Code Review Pipeline

```bash

#!/bin/bash

# code-review.sh FILE

FILE=$1

CODE=$(cat "$FILE")

# Step 1: Static analysis

echo "=== Linting ===" > /tmp/review.txt

npx eslint "$FILE" 2>&1 >> /tmp/review.txt

# Step 2: Type check

echo "" >> /tmp/review.txt

echo "=== Type Check ===" >> /tmp/review.txt

npx tsc --noEmit "$FILE" 2>&1 >> /tmp/review.txt

# Step 3: AI review

echo "" >> /tmp/review.txt

echo "=== AI Review ===" >> /tmp/review.txt

gemini -m pro -o text -e "" "Review this code:

$CODE

Check for:

• Bugs
• Security issues
• Performance problems
• Best practices violations" >> /tmp/review.txt

cat /tmp/review.txt

```

Documentation Pipeline

```bash

#!/bin/bash

# document.sh FILE

FILE=$1

CODE=$(cat "$FILE")

# Generate docs

DOCS=$(gemini -m pro -o text -e "" "Generate documentation for:

$CODE

Include:

• Overview
• Function descriptions
• Parameter docs
• Examples")

# Generate README section

README=$(echo "$DOCS" | gemini -m pro -o text -e "" "Convert to README.md format")

# Generate inline comments

COMMENTED=$(gemini -m pro -o text -e "" "Add JSDoc comments to:

$CODE")

echo "=== Documentation ==="

echo "$DOCS"

echo ""

echo "=== Commented Code ==="

echo "$COMMENTED"

```

Research Pipeline

```bash

#!/bin/bash

# research.sh TOPIC

TOPIC=$1

# Step 1: Initial research

echo "Researching: $TOPIC"

INITIAL=$(gemini -m pro -o text -e "" "Research: $TOPIC. Focus on practical aspects.")

# Step 2: Find gaps

GAPS=$(echo "$INITIAL" | gemini -m pro -o text -e "" "What questions remain unanswered?")

# Step 3: Fill gaps

FOLLOWUP=$(echo "$GAPS" | gemini -m pro -o text -e "" "Answer these remaining questions about $TOPIC")

# Step 4: Synthesize

gemini -m pro -o text -e "" "Create comprehensive summary:

Initial Research:

$INITIAL

Follow-up:

$FOLLOWUP

Provide:

1. Key findings
2. Recommendations
3. Next steps"

```

With Retry

```bash

#!/bin/bash

# retry-pipeline.sh

retry() {

local n=1

local max=3

local delay=2

while true; do

"$@" && return 0

if [[ $n -lt $max ]]; then

((n++))

echo "Retry $n/$max in ${delay}s..."

sleep $delay

else

return 1

fi

done

}

# Use in pipeline

retry gemini -m pro -o text -e "" "Your prompt"

```

With Fallback

```bash

#!/bin/bash

# fallback-pipeline.sh

# Try Claude, fallback to Gemini

result=$(claude --print "Question" 2>/dev/null) || \

result=$(gemini -m pro -o text -e "" "Question")

echo "$result"

```

1. Save intermediate results - Debug easier
2. Add timeouts - Prevent hanging
3. Handle errors - Check return codes
4. Log progress - Track long pipelines
5. Test incrementally - Verify each step
6. Use temp files - For complex data
7. Clean up - Remove temp files after