15 Prompts for GPT-4: From Code Generation to System Architecture
You open ChatGPT, paste a problem, and get working code. But the next day, you're stuck debugging a bug that the same model helped create. The difference between a time-saver and a time-waster? The prompt.
As a developer who uses GPT-4 daily for coding, debugging, and refactoring, I’ve collected 15 battle-tested prompts that actually work. No fluff, no theory—just prompts with real examples you can copy and adapt today.
Why Prompts Matter for Programming
GPT-4 (and its successors like GPT-4o and o3-mini) can generate, debug, and refactor code with high accuracy, but only if you describe the context correctly. A vague prompt like "write a sorting function" gives you generic code. A specific prompt with constraints, edge cases, and expected output gives you production-ready logic.
According to OpenAI’s own documentation (platform.openai.com/docs/guides/prompt-engineering), six key strategies improve results: write clear instructions, provide reference text, split complex tasks into simpler subtasks, give the model time to "think," use external tools, and test changes systematically.
15 Prompts with Real Examples
1. Generate a Complete Function with Edge Cases
Prompt:
Write a Python function calculate_shipping_cost(weight, distance, express=False) that:
- Returns a float cost.
- Handles weight <= 0 (raise ValueError with message "Weight must be positive").
- Handles distance <= 0 (raise ValueError with message "Distance must be positive").
- Base cost: $5 for first 1 kg and 10 km.
- Additional cost: $0.50 per additional kg, $0.10 per additional km.
- Express: add $10 flat fee.
- Include type hints and a docstring with examples.
Why it works: It specifies function signature, edge cases, error handling, pricing logic, and documentation requirements. The model knows exactly what to produce.
Real output (GPT-4, March 2025):
def calculate_shipping_cost(weight: float, distance: float, express: bool = False) -> float:
"""
Calculate shipping cost based on weight and distance.
Args:
weight: Weight in kg. Must be positive.
distance: Distance in km. Must be positive.
express: If True, adds $10 flat fee.
Returns:
Total shipping cost as float.
Raises:
ValueError: If weight or distance is not positive.
Examples:
>>> calculate_shipping_cost(1, 10)
5.0
>>> calculate_shipping_cost(2.5, 20)
5.0 + 0.75 + 1.0 = 6.75
"""
if weight <= 0:
raise ValueError("Weight must be positive")
if distance <= 0:
raise ValueError("Distance must be positive")
base = 5.0
extra_weight = max(0, weight - 1) * 0.50
extra_distance = max(0, distance - 10) * 0.10
total = base + extra_weight + extra_distance
if express:
total += 10.0
return total
2. Debug with Expected vs Actual Behavior
Prompt:
I have this Python code that filters a list of dictionaries. Expected: return items where 'status' is 'active' and 'age' > 18. Actual: it returns all items. Find the bug and fix it.
Code:
data = [{'name': 'Alice', 'status': 'active', 'age': 25}, {'name': 'Bob', 'status': 'inactive', 'age': 30}]
result = [item for item in data if item['status'] == 'active' if item['age'] > 18]
Why it works: You provide the code, expected output, actual output, and context. The model can isolate the issue—here, using two if keywords in list comprehension creates nested conditions, not an AND condition.
Fix: Use and instead of two if statements.
3. Refactor for Performance or Readability
Prompt:
Refactor this JavaScript function for readability and performance. It calculates Fibonacci numbers recursively. Use memoization. Add JSDoc comments.
function fib(n) {
if (n <= 1) return n;
return fib(n-1) + fib(n-2);
}
Why it works: You specify the goal (readability + performance), the technique (memoization), and documentation format (JSDoc). The model produces optimized code without changing the interface.
4. Generate Unit Tests from a Function
Prompt:
Generate pytest unit tests for the following Python function. Include tests for normal cases, edge cases, and error cases. Use parametrize.
def divide(a: float, b: float) -> float:
if b == 0:
raise ValueError("Division by zero")
return a / b
Why it works: The prompt explicitly asks for parametrize, edge cases, and error tests. The model produces comprehensive tests.
5. Explain Code in Simple Terms
Prompt:
Explain this Python decorator to a junior developer. Include a real-world use case (e.g., logging or timing).
import functools
import time
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
end = time.perf_counter()
print(f"{func.__name__} took {end - start:.4f}s")
return result
return wrapper
6. Suggest Architectural Improvements
Prompt:
I have a monolithic Flask app with 50 endpoints. Suggest a migration plan to microservices. Consider:
- Current stack: Flask, PostgreSQL, Redis.
- Team size: 5 developers.
- Main pain points: deployment takes 30 minutes, scaling is all-or-nothing.
- Suggest first service to extract (e.g., authentication or reporting).
7. Write a SQL Query with Explanation
Prompt:
Write a SQL query to find the top 5 customers by total order value in 2024, including customers who made no orders (show 0). Tables: customers(id, name), orders(id, customer_id, total, order_date). Use LEFT JOIN and COALESCE. Explain each step.
8. Generate Regular Expressions with Test Cases
Prompt:
Write a regex to validate email addresses according to RFC 5322 simplified rules: local part allows letters, digits, dots, underscores, percent, plus, and hyphens; domain part allows letters, digits, hyphens, and dots. Provide test cases that should pass and fail.
9. Convert Code Between Languages
Prompt:
Convert this Python function to TypeScript, keeping the same logic and adding proper types.
def get_user_display_name(user: dict) -> str:
first = user.get('first_name', '')
last = user.get('last_name', '')
if not first and not last:
return user.get('username', 'Unknown')
return f"{first} {last}".strip()
10. Optimize Database Queries
Prompt:
This Django ORM query loads 1000 objects but makes 1001 SQL queries. Optimize it to 1 query using select_related or prefetch_related. Explain the N+1 problem first.
books = Book.objects.all()
for book in books:
print(book.author.name)
11. Create a REST API Endpoint with Validation
Prompt:
Write a Flask endpoint POST /register with JSON body {username, email, password}. Validate: username 3-20 chars alphanumeric, email valid format, password min 8 chars with one uppercase and one digit. Return 201 on success, 400 with error messages on failure. Use marshmallow for validation.
12. Generate Documentation from Code
Prompt:
Generate Markdown documentation for this Python module. Include description, installation, usage examples, and API reference for each public function. Use the docstrings.
# mymodule.py
def add(a: int, b: int) -> int:
"""Add two integers."""
return a + b
def subtract(a: int, b: int) -> int:
"""Subtract b from a."""
return a - b
13. Debug a Race Condition
Prompt:
This Python script sometimes prints "Done" before all threads finish. Identify the race condition and fix it using threading.Event or join().
import threading
import time
def worker():
time.sleep(2)
print("Worker done")
threads = []
for _ in range(5):
t = threading.Thread(target=worker)
t.start()
threads.append(t)
print("Done")
14. Explain a Complex Algorithm Step-by-Step
Prompt:
Explain how the QuickSort algorithm works. Include:
- Step-by-step breakdown with a small example array [3, 6, 8, 10, 1, 2, 1].
- Time and space complexity analysis.
- A Python implementation with comments.
- When to use it vs MergeSort.
15. Review Code for Security Issues
Prompt:
Review this Python Flask code for security vulnerabilities. Check for SQL injection, XSS, CSRF, and insecure deserialization. Suggest fixes.
@app.route('/user/<username>')
def profile(username):
query = f"SELECT * FROM users WHERE username = '{username}'"
result = db.execute(query)
return render_template('profile.html', user=result.fetchone())
Real-World Case Study: Refactoring a Legacy Codebase
Problem: A mid-size e-commerce company had a monolithic Django application with 200+ models and 500+ views. Deployment took 45 minutes, and any change required full regression testing. The team wanted to extract the reporting module into a separate FastAPI service.
Solution using GPT-4 prompts:
1. Prompt for architecture: "Given a Django monolith with 200 models and 500 views, suggest a step-by-step plan to extract the reporting module into a FastAPI microservice. Include API gateway considerations, database sharing strategy, and data synchronization."
2. Prompt for data migration: "Write a Django management command to export all report data (models: Order, Payment, Refund) to a PostgreSQL database for a new FastAPI service. Use bulk_create and handle incremental updates."
3. Prompt for API design: "Design a REST API for a reporting service with endpoints: GET /reports/sales (daily, weekly, monthly), GET /reports/refunds, GET /reports/top-products. Include pagination, date filtering, and caching headers."
4. Prompt for testing: "Generate pytest tests for the new FastAPI reporting endpoints. Include integration tests with a test database, and mock external dependencies."
Results:
- The team extracted the module in 3 weeks instead of estimated 8 weeks.
- Deployment time dropped from 45 minutes to 5 minutes for the rest of the monolith.
- The reporting service scaled independently, handling 10x traffic without affecting the main app.
- Code review time decreased because GPT-4 generated consistent, documented code.
Conclusion
These 15 prompts cover the most common developer tasks: generating, debugging, refactoring, explaining, and designing code. The key is specificity—the more context you provide, the better the output.
Start with one prompt today. Paste a real function, add your constraints, and see the difference. Over time, you'll build a personal library of prompts that save hours each week.
All examples tested with GPT-4 and GPT-4o in May 2025. Results may vary with model updates.
Comments