Crafting Effective Prompts for Image Generation

Welcome back! In the previous lesson, you learned how to generate a simple image using Google's Gemini API and its Nano Banana image model. Now, we will delve deeper into the art of crafting effective prompts to achieve desired image outputs. Crafting a well-thought-out prompt is crucial because it directly influences the quality and relevance of the generated image. In this lesson, we will explore the key components of a prompt: subject, context, and style. Understanding these components will empower you to create more detailed and specific prompts, leading to more accurate and visually appealing images.

A guiding principle for Gemini's image models is worth keeping in mind from the start: describe the scene, don't just list keywords. These models have deep language understanding, so a coherent, descriptive sentence almost always produces a better image than a string of disconnected words.

A prompt is essentially a textual description that guides the image generation process. It consists of three main components: subject, context, and style. The subject is the primary focus of the image, such as a cat or a landscape. The context provides additional details about the setting or environment, like a bustling city at night. The style defines the artistic approach, such as digital art or watercolor painting. Each component plays a vital role in shaping the final image.

For example, a simple prompt like "A cat" might generate a generic image of a cat. However, by adding context and style, such as "A black cat sitting on a windowsill overlooking a bustling city at night, in the style of digital art," you can create a more vivid and specific image. This detailed prompt provides the model with more information, resulting in a richer and more accurate output.

Let's walk through the code provided in app/solution.py to see how different prompts affect the generated images. The code initializes the Gemini client using your API key and defines a list of prompts with varying levels of detail. For each prompt, the code uses the generate_content method to request an image from the Gemini API.

from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO
import os
import time

# Retrieve API key from system environment variable
api_key = os.getenv("GOOGLE_API_KEY")

if not api_key:
    raise ValueError("GOOGLE_API_KEY not found in environment variables. Set it before running the script.")

base_url = os.getenv("GOOGLE_BASE_URL")

if not base_url:
    raise ValueError("GOOGLE_BASE_URL not found in environment variables. Set it before running the script.")

# Initialize the Gemini client
client = genai.Client(
    api_key=api_key,
    http_options=types.HttpOptions(
        base_url=base_url,
    ),
)

# Define prompts with varying detail
prompts = [
    "A cat",
    "A black cat sitting on a windowsill",
    "A black cat sitting on a windowsill overlooking a bustling city at night, in the style of digital art",
    "A close-up of a black cat sitting on a windowsill overlooking a bustling city at night, in the style of digital art",
]

# Generate images for each prompt
for prompt in prompts:
    response = client.models.generate_content(
        model="gemini-3.1-flash-image",
        contents=[prompt],
        config=types.GenerateContentConfig(
            response_modalities=["TEXT", "IMAGE"],
        ),
    )
    # Process and display the generated image
    for part in response.parts:
        if part.inline_data is not None:
            image = Image.open(BytesIO(part.inline_data.data))
            timestamp = int(time.time() * 1000)  # Milliseconds precision
            image_filename = f"image_{timestamp}.png"
            output_path = os.path.join("static", "images", image_filename)
            os.makedirs(os.path.dirname(output_path), exist_ok=True)
            image.save(output_path)

As you can see, the code iterates over each prompt, generating an image for each one. The level of detail in the prompt directly affects the complexity and specificity of the generated image. By experimenting with different prompts, you can observe how the model interprets and visualizes the descriptions.

The use of timestamps in the file naming process serves two important purposes. First, it ensures that each generated image has a unique filename, preventing files from being overwritten when saved to the same directory. Second, the timestamp provides a simple and effective way to sort and track images by the order in which they were generated, which can be useful for debugging or analyzing model performance over time.

A Cat:

A black cat sitting on a windowsill overlooking a bustling city at night, in the style of digital art: