Welcome to the first lesson of our Building an Image Generation Service with PHP course! In this course, you'll learn how to build a complete web application that transforms text descriptions into stunning images using the Official Gemini API for image generation.

Before we dive into PHP frameworks or API integration, we need to establish a solid foundation for our image generation system. At the heart of any AI image generation service is the prompt — the text instructions that guide the AI in creating the image you want.

Prompt engineering is the art and science of crafting effective instructions for AI models. When working with image generation models, the quality and structure of your prompts directly impact the quality of the images you receive. A well-crafted prompt provides clear direction, specific details, and appropriate context to help the AI understand exactly what you're looking for.

In our application, we'll be creating event banners for a fictional company called Eventify Co. Rather than crafting a new prompt each time a user requests an image, we'll create a template system that:

1. Maintains consistent structure and quality across all prompts.
2. Allows users to customize only the specific event details.
3. Handles the formatting and presentation of the prompt automatically.

This approach ensures that our application produces high-quality, consistent results while still allowing for customization.

Later in the course, we'll connect this prompt system to the Gemini API's gemini-3.1-flash-image model to generate the actual images. Let's begin by understanding what makes an effective prompt template.

A well-structured prompt template for image generation typically contains several key components that work together to guide the AI. Let's examine the structure of our template:

# ROLE
Lead graphic designer

# THEME 
{user_input}

# TASK
Your task is to create a visually stunning, high-quality event banner that prominently features the event name and tagline. Avoid adding any other text. Ensure the text is well-integrated with the design, enhancing readability and aesthetic appeal.

# ASPECT RATIO
Create the image using a {aspectRatio} aspect ratio.

# DESIGN REQUIREMENTS
- Color Palette: Muted gold, deep navy blue, charcoal black, ivory white.
- Style: Sophisticated pastel shades and metallic accents conveying exclusivity and elegance.
- Typography: 
  - Headings: Serif fonts for event names.
  - Descriptions: Sleek sans-serif fonts for taglines and additional information.
- Composition: Visual clarity and balance with generous spacing and harmonious layout.

# OUTPUT REQUIREMENTS
The banner must be suitable for:
- Social media
- Websites
- Print

Ensure high resolution and impeccable visual quality. Maintain brand consistency and deliver a polished, impactful design ready for promotional use.

Let's break down each section:

ROLE: This establishes the persona the AI should adopt. By positioning the AI as a lead graphic designer, we're setting expectations for high-quality, professional output.

THEME: This is where we'll insert the user's input — the specific event details they want to feature in the banner. Notice the {user_input} placeholder, which we'll programmatically replace with actual content.

TASK: This section clearly defines what we want the AI to create — an event banner with specific characteristics. It provides direction on how text should be integrated into the design.

ASPECT RATIO: This section specifies the dimensions of the generated image. We use the {aspectRatio} placeholder to allow dynamic control over the image shape (e.g., 16:9 or 1:1).

DESIGN REQUIREMENTS: Here, we provide specific design guidelines, including color palette, style, typography, and composition. These details help ensure consistency across all generated images and align with the brand identity of Eventify Co.

OUTPUT REQUIREMENTS: This final section specifies the practical requirements for the image, ensuring it will be suitable for various use cases.

By structuring our prompt this way, we're providing comprehensive guidance to the AI while still allowing for customization through the user input. This balance is key to creating a flexible yet consistent image generation system.

Now that we understand the structure of our prompt template, let's create the actual file that will store it. In our application, we'll organize files according to their function, with templates stored in a dedicated directory.

First, let's set up our project directory structure:

app/
├── data/
│   └── image_prompt_template.txt
├── models/
│   └── PromptManager.php
└── main.php

The data/ directory will store our template and potentially other data files. The models/ directory will contain our PHP classes, and main.php will be our entry point for testing.

Now, let's create the image_prompt_template.txt file in the data/ directory with the content we discussed in the previous section. You can use any text editor to create this file and save it with the exact structure we reviewed earlier.

Make sure the file is saved with UTF-8 encoding to handle any special characters properly. The placeholders {user_input} and {aspectRatio} are crucial — these allow our code to dynamically insert specific details into the template.

public static function loadBasePrompt($filePath = 'data/image_prompt_template.txt') {
    /** Load the base prompt from a file. */
    try {
        if (!file_exists($filePath)) {
            throw new Exception("File not found.");
        }
        return file_get_contents($filePath);
    } catch (Exception $e) {
        echo "Error loading prompt template: " . $e->getMessage();
        return (
            "# ROLE\nYou are a professional graphic designer.\n\n" .
            "# THEME\n{user_input}\n\n" .
            "# TASK\nPlease generate a beautiful banner in {aspectRatio} aspect ratio.\n"
        );
    }
}

The loadBasePrompt method:

• Takes an optional $filePath parameter with a default value pointing to our template file.
• Checks if the file exists using file_exists and reads its contents via file_get_contents.
• Returns the contents as a string if successful.
• If an error occurs (e.g., the file doesn't exist), it prints an error message and returns a simplified fallback template containing our placeholders.

In this lesson, we built the foundation for our image generation service by designing a reusable and resilient prompt template system. You now have the tools to load a template, insert dynamic content, and gracefully handle errors using PHP.

In the practice session, you'll get hands-on experience modifying templates, trying different inputs, and reinforcing the techniques covered here.

Next, we'll continue building our service by creating an ImageManager class to manage the storage and retrieval of generated images using PHP.

From there, we'll connect this prompt system to the official Gemini API image generation flow using gemini-3.1-flash-image to turn these carefully crafted prompts into actual images. Great job completing the first lesson!