Generate and Review Code with the Gemini API (2026)

The Gemini API doesn’t just generate code; it actively understands your existing codebase to suggest improvements and identify potential issues.

Let’s see it in action. Imagine you have a Python script that fetches data from an API and processes it.

import requests
import json

def fetch_and_process_data(url):
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()  # Raise an exception for bad status codes
        data = response.json()
        processed_data = []
        for item in data:
            # Simple processing: convert a field to uppercase
            if 'name' in item:
                item['name'] = item['name'].upper()
            processed_data.append(item)
        return processed_data
    except requests.exceptions.RequestException as e:
        print(f"Error fetching data: {e}")
        return None
    except json.JSONDecodeError:
        print("Error decoding JSON response.")
        return None

if __name__ == "__main__":
    api_url = "https://jsonplaceholder.typicode.com/users"
    result = fetch_and_process_data(api_url)
    if result:
        print(json.dumps(result, indent=2))

Now, let’s ask Gemini to review this code. We can feed it the code snippet and ask for suggestions on improvements, potential bugs, or best practices.

Prompt to Gemini:

"Review the following Python code. Identify any potential issues, suggest improvements for efficiency or robustness, and check for adherence to common Python best practices."

Gemini’s Response (simulated):

"Your code is a good start for fetching and processing data. Here are some suggestions:

Error Handling Granularity: While you catch requests.exceptions.RequestException, it’s a broad exception. You might want to specifically catch requests.exceptions.Timeout and requests.exceptions.HTTPError for more targeted error messages and handling.

Current:

except requests.exceptions.RequestException as e:
    print(f"Error fetching data: {e}")
    return None

Suggestion:

except requests.exceptions.Timeout:
    print("Error: The request timed out.")
    return None
except requests.exceptions.HTTPError as e:
    print(f"Error: HTTP error occurred - {e.response.status_code}")
    return None
except requests.exceptions.RequestException as e:
    print(f"An unexpected error occurred during the request: {e}")
    return None

Why it works: This provides more specific feedback to the user about what went wrong with the HTTP request, aiding in quicker debugging.

Data Structure Assumption: Your code assumes the response is always a list of dictionaries, and that each dictionary will have a 'name' key. If the API returns a different structure or the 'name' key is missing, your processing loop might fail or behave unexpectedly.
- Suggestion: Add a check for the expected data structure and handle missing keys more gracefully.
- Example:
```
if isinstance(data, list):
    for item in data:
        if isinstance(item, dict) and 'name' in item:
            item['name'] = item['name'].upper()
        # else: handle items that are not dicts or lack 'name'
        processed_data.append(item)
else:
    print("Warning: API response was not a list as expected.")
    # Decide how to handle non-list responses
```
- Why it works: This makes your code more resilient to variations in API responses, preventing unexpected crashes.
Secret Management: If api_url were to contain sensitive information (like an API key), it should not be hardcoded. Consider using environment variables or a configuration management system.
- Suggestion:
```
import os
api_url = os.environ.get("DATA_API_URL", "https://jsonplaceholder.typicode.com/users")
```
- Why it works: Environment variables decouple configuration from code, improving security and deployability.

Efficiency for Large Datasets: For very large datasets, creating a new processed_data list and appending to it can be memory-intensive. A generator could be more memory-efficient if the caller only needs to iterate over the processed items.

Suggestion:

def fetch_and_process_data_generator(url):
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
        if isinstance(data, list):
            for item in data:
                if isinstance(item, dict) and 'name' in item:
                    item['name'] = item['name'].upper()
                yield item # Yield processed item
        else:
            print("Warning: API response was not a list as expected.")
    except requests.exceptions.RequestException as e:
        print(f"Error fetching data: {e}")
    except json.JSONDecodeError:
        print("Error decoding JSON response.")

# ... in main block ...
# for processed_item in fetch_and_process_data_generator(api_url):
#    print(processed_item)

Why it works: Generators produce items on demand, significantly reducing memory usage for large sequences by avoiding the creation of a full list in memory.

Type Hinting: Adding type hints can improve code readability and allow static analysis tools to catch potential type errors.
- Suggestion:
```
from typing import List, Dict, Any, Optional

def fetch_and_process_data(url: str) -> Optional[List[Dict[str, Any]]]:
    # ... function body ...
```
- Why it works: Type hints make function signatures explicit, serving as documentation and enabling tools like MyPy to find type mismatches before runtime.

The Gemini API allows you to interact with code not just as text, but as a structured entity with dependencies, potential flaws, and areas for enhancement. This capability extends to generating entirely new code snippets or even entire functions based on natural language descriptions of desired functionality.

When generating code, you can be quite specific. For example, asking "Write a Python function that takes a list of integers and returns a new list containing only the even numbers, using a list comprehension" will yield a precise and idiomatic solution. The real power, however, lies in its ability to understand context. If you provide it with your existing codebase and say, "Add a rate-limiting mechanism to this API client function," it can integrate the new logic intelligently, respecting your current structure and conventions.

One aspect that often surprises developers is how Gemini can infer the intent behind a piece of code, even if it’s not perfectly written. It can identify a developer’s goal – for instance, to serialize an object – and suggest the most Pythonic way to achieve it, even if the original code uses a less efficient or more verbose method. This is because it’s trained on a massive corpus of code and associated documentation, allowing it to recognize patterns of intent and best practices across various languages and frameworks.

The next step in exploring the Gemini API for code generation and review is to leverage its multi-modal capabilities, allowing you to integrate code generation directly into your IDE or CI/CD pipelines based on more complex triggers.