2.1 Understanding the Importance of Prompts
A prompt is the instruction or query you give an AI model, such as OpenAI Codex or GitHub Copilot. The quality of the code the AI generates is heavily dependent on the quality of the prompt you provide. To ensure the AI generates useful, functional code, you need to be:
- Clear: Your prompt should leave little to ambiguity. Vague instructions lead to vague or incorrect code.
- Specific: The more details you provide, the more accurate the generated code will be.
- Contextual: The AI needs to understand the context in which the code is being used. If it doesn’t have the full picture, it may generate code that is either too generic or incorrect.
In this lesson, we’ll walk through how to construct prompts for different coding tasks, focusing on examples across various programming languages.
2.2 Best Practices for Writing Effective Prompts
Here are key principles for crafting prompts that maximize AI’s ability to generate functional, high-quality code:
State the Goal:
- Tell the AI what you need the code to accomplish. For example, instead of saying “Write a function,” say “Write a Python function that calculates the factorial of a number.”
Be Specific with Input/Output:
- Provide sample input and expected output where possible. This helps the AI understand the required functionality more clearly.
Provide Context:
- If the code is part of a larger project, mention any relevant details. For instance, specify if you are using a particular framework or API.
Include Edge Cases:
- Mention specific edge cases to test if the code can handle them, such as large inputs, empty data, or invalid data types.
2.3 Examples of Crafting Effective Prompts
Here are several examples of well-crafted prompts across different tasks and programming languages.
Example 1: Simple Code Generation in Python
Task: Create a function that checks if a number is prime.
Weak Prompt:
- “Write a function to check if a number is prime.”
Strong Prompt:
- “Write a Python function named
is_prime(n) that returns True if the number n is prime and False otherwise. The function should handle edge cases where n is less than 2, and it should be optimized for larger numbers. For example, is_prime(5) should return True and is_prime(4) should return False.”
Generated Code:
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
Explanation: The improved prompt specifies the function’s name, the expected behavior, and edge cases like numbers less than 2, helping the AI generate a more accurate and optimized solution.
Example 2: Code Generation in JavaScript (Handling Edge Cases)
Task: Create a function that sums an array of numbers.
Weak Prompt:
- “Write a function to sum an array.”
Strong Prompt:
- “Write a JavaScript function called
sumArray(arr) that takes an array of numbers arr as input and returns the sum of the numbers. The function should handle cases where the array is empty or contains non-numeric values by returning 0 or skipping the non-numeric values. For example, sumArray([1, 2, 3]) should return 6, and sumArray([1, 'a', 3]) should return 4.”
Generated Code:
function sumArray(arr) {
let sum = 0;
for (let num of arr) {
if (typeof num === 'number') {
sum += num;
}
}
return sum;
}Explanation: The prompt clearly defines the expected behavior and edge cases, such as non-numeric values in the array. This helps the AI generate a solution that handles such cases appropriately.
Example 3: Using AI for API Integration (Python + Requests)
Task: Write code to fetch user data from a public API (e.g., JSONPlaceholder).
Weak Prompt:
- “Write code to fetch data from an API.”
Strong Prompt:
- “Write a Python function using the
requests library that fetches user data from the public API https://jsonplaceholder.typicode.com/users. The function should return the data in JSON format. If there’s an error in fetching the data (e.g., network issues or invalid response), the function should return None and print an error message. The function should return the list of users when successful.”
Generated Code:
import requests
def fetch_user_data():
try:
response = requests.get('https://jsonplaceholder.typicode.com/users')
response.raise_for_status() # Check if the request was successful
return response.json() # Return the JSON data
except requests.exceptions.RequestException as e:
print(f"Error fetching data: {e}")
return None
Explanation: This prompt is specific about the API, error handling, and expected output. It allows the AI to generate a function that is both functional and robust.
Example 4: Refactoring and Optimization
Task: Optimize a basic sorting algorithm.
Weak Prompt:
- “Optimize this sorting code.”
Strong Prompt:
- “Given the following Python function that sorts a list of numbers using bubble sort, refactor it to use a more efficient sorting algorithm, such as merge sort or quicksort. The new function should work with a list of integers and improve the time complexity. Here’s the original code:
def bubble_sort(arr): for i in range(len(arr)): for j in range(0, len(arr)-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j]. Refactor it to improve performance.”
Generated Code:
def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)
Explanation: The refined prompt specifies the code to be optimized, clarifies the expected improvements (e.g., time complexity), and suggests a specific alternative (merge sort or quicksort). This leads to a more efficient algorithm being generated.
2.4 Tips for Refining Prompts
Clarify Output:
- Be specific about what you expect as output. Do you need the result returned as a string, list, dictionary, or in a particular format? For example: “Return the result as a dictionary with keys
status and data.”
Iterative Refinement:
- If the AI generates incorrect or incomplete code, refine the prompt by adding more specific details. Provide more context or ask for a particular optimization.
Ask for Explanations:
- For complex code, you can ask the AI to explain its solution. For example: “After generating the sorting algorithm, explain why you chose quicksort and how it works.”
Practical Exercise:
Task:
Write a prompt for an AI that asks it to generate a Python function to calculate the nth Fibonacci number. Be sure to include edge cases such as when the input is negative or zero.
Example Prompt:
- “Write a Python function named
fibonacci(n) that returns the nth Fibonacci number. If n is negative, the function should return None with an error message. If n is 0, it should return 0. The function should work efficiently for large numbers, and handle the case where n is a very large integer gracefully.”
2.5 Key Takeaways from This Lesson:
- Clear, specific, and contextual prompts lead to higher-quality AI-generated code.
- Always define the goal, expected inputs, and outputs, and provide any necessary edge cases or context.
- Refine prompts iteratively based on the AI’s output, and use AI to generate efficient, optimized code.
- Prompting AI is a skill that improves with practice. The more precisely you can frame your requests, the better the results you will get.
In the next lesson, we’ll explore how to use AI for code refactoring and optimization, taking existing code and improving its performance and readability using AI-generated suggestions.
