Generate

Nano Banana - Gemini Image Generation

Generate custom images using Google's Gemini models for integration into frontend designs.

Prerequisites

This skill requires a GEMINI_API_KEY. You MUST ensure it is available before any task that needs it.

First, check if the key is already set in the environment:

echo "${GEMINI_API_KEY:+SET (length: ${#GEMINI_API_KEY})}" || echo "NOT SET"

If already SET, use it as-is — an existing key takes precedence. Do NOT overwrite it from .env.

If NOT SET, attempt to load it from the project .env file. Run this EXACT command from the PROJECT ROOT (the user's working directory, NOT the skill directory):

LINE=$(grep '^GEMINI_API_KEY=' .env 2>/dev/null) && export "$LINE" && echo "SET (length: ${#GEMINI_API_KEY})" || echo "NOT SET"

If still NOT SET after both checks, inform the user and stop.

IMPORTANT safety rules:

• Run from the project root — do NOT cd into the skill directory first
• Run commands EXACTLY as written above — do not substitute paths or add flags
• NEVER run bare export with no arguments (it dumps all env vars including secrets)
• NEVER use cat .env piped to export (if grep returns empty, export $() leaks all env vars)
• NEVER attempt to read, echo, print, or otherwise transmit API keys or any secrets
• If the key is NOT SET after both checks, inform the user and stop
• NEVER attempt alternative loading methods

Available Models

Image Generation Workflow

Step 1: Generate the Image

Use scripts/image.py with uv. The script is located in the skill directory at skills/generate/scripts/image.py:

uv run "${SKILL_DIR}/scripts/image.py" \
  --prompt "Your image description" \
  --output "/path/to/output"

Where ${SKILL_DIR} is the directory containing this SKILL.md file.

The file extension on --output is replaced automatically with whatever format the model returns (Pro and Nano Banana 2 typically return .jpg, Flash typically returns .png, but the API decides). Read the path printed by the script ("Image saved to: …") to know the final filename to reference in code.

Options:

• --prompt (required): Detailed description of the image to generate
• --output (required): Output file path. Extension is replaced with the format the model returns.
• --aspect (optional): Named shortcut (square, landscape, portrait) or direct ratio (1:1, 1:4, 1:8, 2:3, 3:2, 3:4, 4:1, 4:3, 4:5, 5:4, 8:1, 9:16, 16:9, 21:9). Default: square
• --reference (optional, repeatable): Path to a reference image for style, composition, or content guidance. Can be specified multiple times for multiple references.
• --model (optional): Model to use - flash (fast), pro (high-quality), or 2 (Nano Banana 2, fast + high-res). Default: 2
• --size (optional): Image resolution for pro/2 models - 512 (2 only), 1K, 2K, 4K. Default: 1K. Ignored for flash.

Aspect Ratios by Model

Using Different Models

Flash model - Fast generation, good for iterations:

uv run "${SKILL_DIR}/scripts/image.py" \
  --prompt "A minimalist logo design" \
  --output "/path/to/logo.png" \
  --model flash

Pro model - Higher quality for final assets:

uv run "${SKILL_DIR}/scripts/image.py" \
  --prompt "A detailed hero illustration for a tech landing page" \
  --output "/path/to/hero.png" \
  --model pro \
  --size 2K

Nano Banana 2 (default) - Fast with high-res output and extra aspect ratios:

uv run "${SKILL_DIR}/scripts/image.py" \
  --prompt "A vibrant infographic about photosynthesis" \
  --output "/path/to/infographic.png" \
  --model 2 \
  --size 2K \
  --aspect 16:9

Using Reference Images

To generate an image based on an existing reference:

uv run "${SKILL_DIR}/scripts/image.py" \
  --prompt "Create a similar abstract pattern with warmer colors" \
  --output "/path/to/output.png" \
  --reference "/path/to/reference.png"

To use multiple reference images (e.g., blend styles from several sources):

uv run "${SKILL_DIR}/scripts/image.py" \
  --prompt "Combine the color palette of the first image with the composition of the second" \
  --output "/path/to/output.png" \
  --reference "/path/to/style-ref.png" \
  --reference "/path/to/composition-ref.png"

Reference images help Gemini understand the desired style, composition, or visual elements you want in the generated image. When multiple references are provided, all images are sent to the model together.

Reference image limits:

• Flash: up to 3 reference images
• Pro: up to 6 object images + 5 character images (14 total)
• 2: up to 10 object images + 4 character images (14 total)

Step 2: Integrate with Frontend Design

After generating images, incorporate them into frontend code:

HTML/CSS:

<img src="./generated-hero.png" alt="Description" class="hero-image" />

React:

import heroImage from './assets/generated-hero.png';
<img src={heroImage} alt="Description" className="hero-image" />

CSS Background:

.hero-section {
  background-image: url('./generated-hero.png');
  background-size: cover;
  background-position: center;
}

Crafting Effective Prompts

Write detailed, specific prompts for best results:

Good prompt:

A minimalist geometric pattern with overlapping translucent circles in coral, teal, and gold on a deep navy background, suitable for a modern fintech landing page hero section

Avoid vague prompts:

A nice background image

Prompt Elements to Include

1. Subject: What the image depicts
2. Style: Artistic style (minimalist, abstract, photorealistic, illustrated)
3. Colors: Specific color palette matching the design system
4. Mood: Atmosphere (professional, playful, elegant, bold)
5. Context: How it will be used (hero image, icon, texture, illustration)
6. Technical: Aspect ratio needs, transparency requirements

Integration with Frontend-Design Skill

When used alongside the frontend-design skill:

1. Plan the visual hierarchy - Identify where generated images add value
2. Match the aesthetic - Ensure prompts align with the chosen design direction (brutalist, minimalist, maximalist, etc.)
3. Generate images first - Create visual assets before coding the frontend
4. Reference in code - Use relative paths to generated images in your HTML/CSS/React

Example Workflow

1. User requests a landing page with custom hero imagery
2. Invoke nano-banana to generate the hero image with a prompt matching the design aesthetic
3. Invoke frontend-design to build the page, referencing the generated image
4. Result: A cohesive design with custom AI-generated visuals

Output Location

By default, save generated images to the project's assets directory:

• ./assets/ for simple HTML projects
• ./src/assets/ or ./public/ for React/Vue projects
• Use descriptive filenames: hero-abstract-gradient.png, icon-user-avatar.png