10 o3-mini Prompts to Help with All Your Coding Tasks

o3-mini has proven to be OpenAI’s most advanced model for coding and reasoning. The o3-mini (high) model has single-handedly outperformed other existing models like DeepSeek-R1 and Claude 3.5 in most standard benchmark tests. Owing to this, ChatGPT powered by o3-mini has now become an everyday companion for developers. It offers them an intelligent and efficient way to tackle programming challenges—be it debugging, code generation, documentation, or data cleaning. This article lists 10 ChatGPT prompts that can help you unlock the full potential of o3-mini for your coding tasks. So, let’s get started!

1. Debugging Code Errors

Suppose you are working on a Python script for a web app, and suddenly, you encounter an error that you don’t understand. The traceback message is long and confusing, and you are unsure how to fix it. o3-mini offers a quick way to debug the issue and understand what went wrong.

Template Prompt: “I have a piece of code in [language] that is throwing an error: [error message]. Can you help me debug it? [insert code]”

Sample Prompt:

“I have a piece of Python code that is throwing an error: AttributeError: ‘NoneType’ object has no attribute ‘group’. Can you help me debug it?”

import pandas as pd

# Sample data
data = {
    "Product": ["Laptop", "Headphones", "Smartphone", "Monitor", "Mouse"],
    "Category": ["Electronics", "Electronics", "Electronics", "Accessories", "Accessories"],
    "Sales": ["$1000", "$200", "$800", "$300", "$50"]  # Sales values contain a '$' sign
}

df = pd.DataFrame(data)

# Convert Sales column to float
df["Sales"] = df["Sales"].astype(float)  # 🚨 This line throws a ValueError

# Calculate total sales per category
total_sales = df.groupby("Category")["Sales"].sum()

print(total_sales)

Output of Code:

o3-mini’s Response:

import pandas as pd

# Sample data
data = {
    "Product": ["Laptop", "Headphones", "Smartphone", "Monitor", "Mouse"],
    "Category": ["Electronics", "Electronics", "Electronics", "Accessories", "Accessories"],
    "Sales": ["$1000", "$200", "$800", "$300", "$50"]  # Sales values contain a '$' sign
}

df = pd.DataFrame(data)

# Convert Sales column to float after stripping '$'
df["Sales"] = df["Sales"].str.replace("$", "").astype(float)  # ✅ Fixed: Removed currency symbols

# Calculate total sales per category
total_sales = df.groupby("Category")["Sales"].sum()

print(total_sales)

Output of Code:

2. Creating a Code Template

When you have a new project at hand, it can often be confusing on where to start. There may be different approaches, or multiple steps involved, or it may require libraries you aren’t familiar with. In such cases, o3-mini can help you get started with a basic code template and guide you through writing the entire code.

Template Prompt: “Can you provide a structured template and guide for writing a [language] project that does [task]?”

Sample Prompt:

“Can you provide a structured template and guide for setting up a Python Flask project that connects to a PostgreSQL database?”

o3-mini’s Response:

3. Converting Code Between Languages

Let’s say you have a piece of code written in one programming language, but your project requires it in another. Instead of rewriting it manually, o3-mini can translate the code for you, preserving the logic and functionality.

Template Prompt: “Can you convert this [source language] code to [target language] while maintaining logic and functionality?”

Sample Prompt:

“Can you convert this Python code to JavaScript (Node.js) while maintaining its logic and functionality?”

from collections import Counter

# Sample text input
text = """
This is a sample text. This text is meant to test word frequency.
Some words appear more than once, some words appear only once.
"""

# Convert to lowercase and split into words
words = text.lower().split()

# Count word occurrences
word_counts = Counter(words)

# Print results
for word, count in word_counts.items():
    print(f"{word}: {count}")

Output of Code:

o3-mini’s Response:

// Sample text input
let text = `
This is a sample text. This text is meant to test word frequency.
Some words appear more than once, some words appear only once.
`;

// Convert to lowercase and split into words
let words = text.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/);

// Count word occurrences
let wordCounts = new Map();

words.forEach(word => {
    wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
});

// Print results
wordCounts.forEach((count, word) => {
    console.log(`${word}: ${count}`);
});

Output of Code:

4. Improving Code Readability

While writing code for work, it is important that the code be readable and easy for all stakeholders to understand. For this, you may have to write documentation, add code comments, or refactor the code for better readability. In such cases, o3-mini can be of great help.

Template Prompt: “Can you generate docstrings and comments for this [language] function?[insert code]”

OR “Can you refactor this [language] code to make it more readable?[insert code]”

Sample Prompt:

“Can you add docstrings and comments to this Python function that processes user input and updates a database?”

import sqlite3  

def update_user_balance(user_id, amount):  
    conn = sqlite3.connect("database.db")  
    cursor = conn.cursor()  
    
    current_balance = cursor.execute("SELECT balance FROM users WHERE id = ?", (user_id,)).fetchone()  
    
    if current_balance:  
        new_balance = current_balance[0] + amount  
        cursor.execute("UPDATE users SET balance = ? WHERE id = ?", (new_balance, user_id))  
        conn.commit()  
        conn.close()  
        return new_balance  
    else:  
        conn.close()  
        return None

o3-mini’s Response:

import sqlite3  

def update_user_balance(user_id, amount):  
    """
    Updates the balance of a user in the database.

    Parameters:
    user_id (int): The unique ID of the user whose balance needs to be updated.
    amount (float): The amount to add to (or subtract from) the user's balance.

    Returns:
    float: The updated balance if the user exists.
    None: If the user does not exist in the database.
    """
    
    # Connect to the SQLite database
    conn = sqlite3.connect("database.db")  
    cursor = conn.cursor()  
    
    # Fetch the current balance of the user
    current_balance = cursor.execute(
        "SELECT balance FROM users WHERE id = ?", (user_id,)
    ).fetchone()  
    
    if current_balance:  
        # Calculate the new balance
        new_balance = current_balance[0] + amount  
        
        # Update the user's balance in the database
        cursor.execute(
            "UPDATE users SET balance = ? WHERE id = ?", (new_balance, user_id)
        )  
        
        # Commit the transaction
        conn.commit()  
        
        # Close the connection
        conn.close()  
        
        return new_balance  # Return the updated balance
    else:  
        # Close the connection if user does not exist
        conn.close()  
        return None  # Return None if user ID is not found

5. Writing Code for Edge Cases and Error Handling

You’re making an API request in Python, but your code doesn’t handle cases where the request fails. You need to add error handling to make it more robust.

Template Prompt: “Can you add proper error handling to this [language] function? [insert function]”

Sample Prompt:

“Can you add proper error handling to this Python function making an API request?”

import requests
response = requests.get("https://api.example.com/data")
data = response.json()

o3-mini’s Response:

import requests

def fetch_api_data(url):
    """
    Fetches data from the given API URL with proper error handling.

    Parameters:
    url (str): The API endpoint to request data from.

    Returns:
    dict or None: The JSON response as a dictionary if successful, or None if an error occurs.
    """
    try:
        response = requests.get(url, timeout=10)  # Set a timeout to avoid hanging requests
        response.raise_for_status()  # Raise an error for HTTP errors (4xx and 5xx)

        return response.json()  # Parse and return JSON response

    except requests.exceptions.Timeout:
        print("Error: The request timed out.")
    except requests.exceptions.ConnectionError:
        print("Error: Failed to connect to the server.")
    except requests.exceptions.HTTPError as err:
        print(f"HTTP Error: {err}")
    except requests.exceptions.RequestException as err:
        print(f"Request Error: {err}")
    except ValueError:
        print("Error: Unable to decode JSON response.")

    return None  # Return None if any error occurs

# Example usage
api_url = "https://api.example.com/data"
data = fetch_api_data(api_url)

if data:
    print("API Data Retrieved Successfully!")
else:
    print("Failed to retrieve API data.")

6. Writing CI/CD Pipeline Configurations

Let’s suppose your team is deploying a Node.js application, and you’ve been assigned the task of setting up an automated CI/CD pipeline. You need to configure GitHub Actions to run tests and deploy the app whenever changes are pushed to the main branch. Here’s a simple prompt you can use on o3-mini to set up the deployment pipeline.

Template Prompt: “Can you generate a CI/CD pipeline configuration for a [technology stack: React, MongoDB, Node.js, etc.] project using [CI/CD tool: GitHub Actions, Jenkins, etc.] that runs tests and deploys to [deployment environment: AWS, AKS, GKE, etc.]?”

Sample Prompt:

“Can you generate a CI/CD pipeline configuration for a Node.js project using GitHub Actions that runs tests and deploys to AWS S3 on every push to the main branch?”

o3-mini’s Response:

name: Node.js CI/CD Pipeline

on:
  push:
    branches:
      - main  # Runs the workflow on pushes to the main branch

jobs:
  build-and-test:
    name: Build and Test
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 18

      - name: Install dependencies
        run: npm install

      - name: Run tests
        run: npm test

      - name: Build project
        run: npm run build

      - name: Upload build artifacts
        uses: actions/upload-artifact@v3
        with:
          name: build-output
          path: dist/
      - name: Deploy to S3
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          AWS_REGION: "us-east-1"  # Change to your AWS region
          S3_BUCKET: "your-s3-bucket-name"
        run: |
          aws s3 sync dist/ s3://$S3_BUCKET --delete

7. Code Optimization and Performance Improvement

Have you ever been in situations where your Python function works fine, but runs slowly on large datasets? If this has been a roadblock in getting your job done, here’s how o3-mini can help you optimize your code for more efficient execution.

Template Prompt: “Can you optimize this code for performance? It currently has issues with [mention inefficiencies] and runs slowly for [mention scenario]. [insert code]”

Sample Prompt:

“Can you optimize this Python code for performance? It currently has inefficiencies in checking for prime numbers and runs slowly when searching for primes in a large range (e.g., 1 to 100,000).”

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True


def find_primes(start, end):
    primes = []
    for num in range(start, end + 1):  
        if is_prime(num):  
            primes.append(num)  
    return primes

# Example usage
start_range = 1
end_range = 10000
primes = find_primes(start_range, end_range)
print(f"Found {len(primes)} prime numbers.")

o3-mini’s Response:

import math

def is_prime(n):
    """Check if a number is prime."""
    if n < 2:
        return False
    if n == 2:
        return True  # 2 is the only even prime number
    if n % 2 == 0:
        return False  # Eliminate even numbers > 2

    # Check divisibility up to √n
    for i in range(3, int(math.sqrt(n)) + 1, 2):
        if n % i == 0:
            return False
    return True

def find_primes(start, end):
    """Find all prime numbers in a given range."""
    primes = []
    for num in range(start, end + 1):
        if is_prime(num):
            primes.append(num)
    return primes

# Example usage
start_range = 1
end_range = 10000
primes = find_primes(start_range, end_range)
print(f"Found {len(primes)} prime numbers.")

Output of Code:

8. Generating Regular Expressions (Regex)

o3-mini can be very helpful in generating regular expressions in code. Suppose you’re building a form validation system for a website and need a regex pattern to validate email addresses. Just ask o3-mini to generate a regex pattern using this prompt.

Template Prompt: “Can you generate a regex pattern in [language] for [task]?”

Sample Prompt:

“Can you generate a regex pattern in Python for validating email addresses?”

o3-mini’s Response:

import re

# Regular expression for email validation
email_pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"

# Function to validate emails
def is_valid_email(email):
    return re.match(email_pattern, email) is not None

Output of Code:

9. Assisting with Data Cleaning and Processing

While analyzing customer sales data in Pandas, you often come across messy datasets, missing values, duplicate entries, and data in multiple formats. Using the following prompt on o3-mini is an efficient way to clean the data before running your analysis.

Template Prompt: “Can you help clean and process a dataset with issues such as [list data issues] using [programming language and library]? [insert dataset]”

Sample Prompt:

“Can you help clean and process a dataset with missing values, duplicate rows, incorrect date formats, and inconsistent capitalization using Python and Pandas? customers.csv”

o3-mini’s Response:

import pandas as pd  

# Load the dataset  
df = pd.read_csv("customers.csv")  

# Standardize column names (remove spaces and convert to lowercase)  
df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")  

# Handle missing values  
df["age"].fillna(df["age"].median(), inplace=True)  # Fill missing ages with median  
df["purchase_amount"].fillna(df["purchase_amount"].mean(), inplace=True)  # Fill missing purchases with mean  

# Remove duplicate rows  
df = df.drop_duplicates()  

# Standardize text data (capitalize names and cities)  
df["name"] = df["name"].str.title()  
df["city"] = df["city"].str.title()  
df["country"] = df["country"].str.upper()  

# Convert dates to a consistent format  
df["join_date"] = pd.to_datetime(df["join_date"], errors="coerce", dayfirst=False)  

# Save the cleaned dataset  
df.to_csv("cleaned_customers.csv", index=False)

print("Data cleaning completed successfully!")

Output of Code:

10. Writing Shell Scripts for Automation

I’m sure you’ll agree with me when I say a lot of our work is repetitive in nature – be it frequently deploying applications or backing up files. Instead of running these commands manually every time, o3-mini can help you automate them through coding. It can write you shell scripts to automate repetitive terminal commands based on your requirements.

Template Prompt: “Can you write a shell script to automate [task] using [specific tools or commands]?”

Sample Prompt:

“Can you write a shell script to automatically back up a directory (/home/user/documents) to another location (/mnt/backup) every day at midnight using cron?”

o3-mini’s Response:

1️. Shell Script (backup.sh)

<pre class="wp-block-code"><code>#!/bin/bash

# Define source and destination directories

SOURCE="/home/user/documents"
DESTINATION="/mnt/backup"
TIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")
BACKUP_DIR="$DESTINATION/backup_$TIMESTAMP"

# Create backup directory

mkdir -p "$BACKUP_DIR"

#Copy files while preserving attributes

rsync -av --delete "$SOURCE/" "$BACKUP_DIR/"

# Log the backup

echo "Backup completed on $(date) to $BACKUP_DIR">>\var\log\backup.log

2️. Make the Script Executable

Run the following command to give the script execution permissions:

chmod +x /path/to/backup.sh

3️. Schedule Daily Backup at Midnight with Cron

Open the crontab editor:

crontab -e

Add this line at the end:

0 0 * * * /path/to/backup.sh

This schedules the script to run daily at midnight (00:00).

Conclusion

As we have in this article, o3-mini is capable of handling all kinds of coding tasks from debugging complex errors and optimizing code for better performance, to writing CI/CD configurations, and converting code between languages. In a way, o3-mini has redefined how developers approach coding challenges by providing intelligent, efficient, and accurate solutions. So go ahead, try out these prompts, and let o3-mini help you work smarter, not harder!

Frequently Asked Questions

K.C. Sabreena Basheer

Sabreena is a GenAI enthusiast and tech editor who's passionate about documenting the latest advancements that shape the world. She's currently exploring the world of AI and Data Science as the Manager of Content & Growth at Analytics Vidhya.