James OnoniwuBill Gates has said it all... be a lazy programmer!.
As a programmer, there’s nothing better than code that works right off the bat—no bugs, no endless debugging. by following certain prompt techniques, you can get ChatGPT to write not just code, but optimised, fully functional, and documented code, complete with edge cases, tests, and even performance optimisations.
But first...
What is Prompt Engineering?
Artificial Intelligence, particularly ChatGPT, has become a powerful tool for content creation, coding assistance, and answering complex questions. Yet, many people don’t tap into its full potential. The magic lies in how you phrase your requests—what we call prompt engineering. In this article, we'll explore techniques that can make your ChatGPT experience more fruitful, highlighting some tricks that can take your prompts from average to brilliant, as a software programmer.
Why Does Prompt Engineering Matter?
ChatGPT is trained on vast amounts of data, but its responses are shaped by the quality of the prompt you give it. Poorly worded or vague prompts can lead to irrelevant or generic answers. Conversely, well-structured prompts can generate thoughtful, accurate, and creative responses.
This guide will help lazy programmers (like myself 🤓) get high-quality, optimised, and even more functional code from ChatGPT using prompt engineering. These will exclusively make ChatGPT do the heavy lifting—automating code generation, improving it, and even suggesting optimisations and tests. Below, I’ve also included examples that compare the normal prompts versus optimised prompts and the results they generate.
So let's get started!.
Triggering Auto-Refinements for Better Code
Ask ChatGPT to automatically refine its responses by embedding triggers to spot inefficiencies, suggest optimisations, or add features.
Basic prompt: "Write a Python function to reverse a string."
def reverse_string(s):
return s[::-1]
# Example usage:
print(reverse_string("hello")) # Output: "olleh"
Optimised prompt: "Write a Python function to reverse a string. If the input is too large or inefficient, suggest a better way to handle large strings efficiently."
def reverse_string(s):
return s[::-1]
# Trigger: Refining for large strings
def reverse_large_string(s):
# Handle large strings in chunks for efficiency
chunk_size = 100000 # Process in 100k chunks
return ''.join(s[i:i+chunk_size][::-1] for i in range(0, len(s), chunk_size))
# Example usage:
large_string = "a" * 1000000 # 1 million characters
print(reverse_large_string(large_string))
The basic function is simple and works for small inputs.
The optimised, introduces an efficient chunk-based solution for reversing large strings without consuming too much memory.
Contextual Memory for Multi-Step Projects
When you need code for multi-step projects, ChatGPT can remember earlier steps. This is ideal for more complex workflows where you build one layer on top of another.
Basic prompt: "Write a Python function to create a user profile."
def create_user_profile(name, age, email):
return {"name": name, "age": age, "email": email}
# Example usage:
user_profile = create_user_profile("Alice", 30, "alice@example.com")
print(user_profile)
Optimised prompt: "Write a Python function to create a user profile. Now, extend this to also store user preferences and connect it with a database to save the profiles."
def create_user_profile(name, age, email, preferences):
return {"name": name, "age": age, "email": email, "preferences": preferences}
# Extend with a database connection
import sqlite3
def save_user_profile(profile):
conn = sqlite3.connect('users.db')
cursor = conn.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS users
(name TEXT, age INTEGER, email TEXT, preferences TEXT)''')
cursor.execute('''INSERT INTO users (name, age, email, preferences)
VALUES (?, ?, ?, ?)''',
(profile['name'], profile['age'], profile['email'], str(profile['preferences'])))
conn.commit()
conn.close()
# Example usage:
user_profile = create_user_profile("Alice", 30, "alice@example.com", {"theme": "dark"})
save_user_profile(user_profile)
The first function from the basic prompt creates a simple user profile.
The second prompt creates a database-connected user profile manager with extended functionality for saving data.
Request Debug Mode for Error-Free Code
You can ask ChatGPT to act as if it’s running in debug mode, where it checks and corrects potential issues in the code before delivering the final output.
Example simple prompt: "Write a Python function to calculate the square root of a number."
import math
def square_root(n):
return math.sqrt(n)
# Example usage:
print(square_root(16)) # Output: 4.0
The Trick: "Write a Python function to calculate the square root of a number. Activate debug mode to check for errors like negative inputs, and rewrite the function if necessary."
import math
def square_root(n):
if n < 0:
return "Error: Cannot calculate square root of a negative number"
return math.sqrt(n)
# Debugged version handles errors properly.
# Example usage:
print(square_root(16)) # Output: 4.0
print(square_root(-16)) # Output: "Error: Cannot calculate square root of a negative number"
The basic function works fine for valid inputs but crashes with negative numbers.
The optimised prompt ensures error handling for negative inputs, returning a custom message instead of breaking the code.
Role-Playing: Act as a Code Reviewer
You can ask ChatGPT to role-play as a senior code reviewer to provide feedback and suggest best practices for your code.
Example prompt: "Act as a senior developer and review my Python function that checks if a number is prime. Suggest improvements for performance and readability."
def is_prime(n):
if n <= 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
# Only check odd numbers up to the square root of n for efficiency
for i in range(3, int(n**0.5) + 1, 2):
if n % i == 0:
return False
return True
# Review:
# - Optimised the loop to check divisibility only up to the square root of n.
# - Reduced checks for even numbers to improve performance for large inputs.
# Example usage:
print(is_prime(5)) # Output: True
print(is_prime(4)) # Output: False
The prompt delivers a more optimised version, only checking odd numbers up to the square root, which dramatically improves performance.
Use Layered Prompting for Multi-Function Outputs
You can stack layers of functionality in a single prompt, asking ChatGPT to handle multiple related tasks in one go.
Basic Prompt: "Write a Python function to generate a random password."
import random
import string
def generate_password(length):
return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
# Example usage:
print(generate_password(10)) # Output: Random 10-character password
Optimised version : "Write a Python function to generate a random password. The password must meet the following criteria: at least 12 characters, contains uppercase, lowercase, numbers, and special characters. Also, write a validation function to check if the password is strong."
import random
import string
import re
def generate_password(length):
characters = string.ascii_letters + string.digits + string.punctuation
password = ''.join(random.choices(characters, k=length))
return password
def validate_password(password):
# Check length
if len(password) < 12:
return "Password too short"
# Check for uppercase, lowercase, digit, and special character
if (not re.search(r'[A-Z]', password) or not re.search(r'[a-z]', password) or
not re.search(r'[0-9]', password) or not re.search(r'[\W_]', password)):
return "Password must contain uppercase, lowercase, digit, and special character"
return "Strong password"
# Example usage:
password = generate_password(12)
print(password) # Output: Random 12-character password
print(validate_password(password)) # Output: "Strong password" or feedback on improvement
The basic prompt generates a random password.
The optimised gives a complex password generator and includes a validation function to check password strength.
Test-Driven Development: Generate a Complete Test Suite
You can ask ChatGPT to write the code along with a full test suite in one go, ensuring your code is ready for production with minimal effort. (If you must ask for help, make sure to ask for a lot 🤓).
Basic Prompt: "Write a Python function to check if a string is a palindrome."
def is_palindrome(s):
return s == s[::-1]
# Example usage:
print(is_palindrome("madam")) # Output: True
print(is_palindrome("hello")) # Output: False
Getting more: "Write a Python function to check if a string is a palindrome. Also, write a full test suite using pytest with edge cases like empty strings and spaces."
def is_palindrome(s):
s = ''.join(c.lower() for c in s if c.isalnum()) # Remove non-alphanumeric characters
return s == s[::-1]
# Test suite
def test_is_palindrome():
assert is_palindrome("madam") == True
assert is_palindrome("hello") == False
assert is_palindrome("A man, a plan, a canal, Panama") == True
assert is_palindrome("") == True # Edge case: empty string
assert is_palindrome(" ") == True # Edge case: only spaces
# Example usage:
print(is_palindrome("A man, a plan, a canal, Panama")) # Output: True
The basic version checks for palindromes but misses edge cases.
The hidden trick not only refines the function by ignoring spaces and punctuation but also provides a comprehensive test suite using pytest.
By mastering these techniques, you can extract high-performance, error-free, and production-ready code from ChatGPT, all while doing less work. With auto-refinements, memory triggers, error handling, and complete test suites, you’ll code smarter, not harder.
