By the end of this lesson, you will:
Definition: Prompt engineering is the practice of crafting precise, well-structured instructions that guide AI systems to generate accurate, relevant, and useful code outputs.
A prompt is your instruction to the AI system. The quality of your prompt directly affects the quality of the generated code.
Essential Elements:
Every effective coding prompt contains several key components working together.
[Context] + [Task] + [Constraints] + [Output Format] = Effective Prompt
Example Breakdown:
"I'm building a web app [Context].
Create a function that validates email addresses [Task].
Use regex and return boolean [Constraints].
Include comments explaining the regex pattern [Output Format]."
| Pattern | Best For | Complexity | Example Use Case |
|---|---|---|---|
| Zero-Shot | Standard tasks | Low | Basic algorithms, utilities |
| Few-Shot | Custom formats | Medium | API responses, data models |
| Chain-of-Thought | Complex logic | High | Algorithm design, debugging |
Asking AI to complete a task without providing examples.
When to Use:
Example:
"Write a Python function to calculate the factorial of a number"
AI Response:
def factorial(n):
"""Calculate the factorial of a non-negative integer."""
if n < 0:
raise ValueError("Factorial is not defined for negative numbers")
elif n == 0 or n == 1:
return 1
else:
result = 1
for i in range(2, n + 1):
result *= i
return result
:bulb: :bulb: Pro Tip Zero-shot prompting works best when the task matches common programming patterns. For unique business logic or specific coding standards, consider few-shot prompting instead.
Providing examples to guide the AI's response format and style.
When to Use:
Example:
"Create functions following this pattern:
Example:
def add_numbers(a: int, b: int) -> int:
"""Adds two numbers and returns the result."""
return a + b
Now create a function that multiplies three numbers."
Asking AI to explain its reasoning step-by-step.
When to Use:
Example:
"Explain step-by-step how to implement a binary search algorithm,
then provide the code with comments for each step."
Use this framework to structure your prompts effectively.
| Letter | Meaning | Description |
|---|---|---|
| C | Context | Provide background information |
| L | Language | Specify programming language and version |
| E | Examples | Include sample inputs/outputs if needed |
| A | Assumptions | State any assumptions or constraints |
| R | Requirements | List specific features or behaviors |
The more specific your prompt, the better the AI output.
Vague Prompt:
"Create a login system"
Specific Prompt:
"Create a Python Flask login system with:
- Username and password validation
- bcrypt for password hashing
- Session management
- Login attempt limiting (max 3 attempts)
- Return JSON responses for API compatibility"
Context helps AI understand your project's bigger picture.
Without Context:
"Write a function to process data"
With Context:
"I'm building a data pipeline for analyzing customer reviews.
Write a function that:
- Takes a list of review dictionaries
- Filters reviews with ratings >= 4
- Extracts only the 'text' and 'rating' fields
- Returns a cleaned list for sentiment analysis"
Assign a specific role or expertise to the AI.
Example:
"Act as a senior Python developer focused on clean code.
Review and refactor this function to follow PEP 8 standards
and improve readability."
Specify exactly how you want the code structured.
Example:
"Create a REST API endpoint for user registration.
Format the response as:
1. Function definition with type hints
2. Input validation
3. Database operations (use comments for pseudo-code)
4. Error handling with specific status codes
5. Success response with user ID"
Build complex solutions through multiple prompts.
First Prompt:
"Create a basic Calculator class with add and subtract methods"
Second Prompt:
"Now add multiply and divide methods with error handling for division by zero"
Third Prompt:
"Add a memory feature that stores the last result and a clear method"
Unclear prompts lead to unexpected results.
Poor Example:
"Make the code better"
Improved Example:
"Optimize this sorting function for:
- Time complexity (prefer O(n log n))
- Memory efficiency
- Readability with clear variable names
- Add error handling for empty lists"
Trying to accomplish too much in one prompt.
Overloaded:
"Create a complete e-commerce system with user authentication,
product management, shopping cart, payment processing,
order tracking, and admin panel"
Better Approach: Break into smaller, focused prompts:
Forgetting to specify how to handle special situations.
Incomplete Prompt:
"Write a function to calculate average of a list"
Complete Prompt:
"Write a function to calculate average of a list.
Handle:
- Empty lists (return 0)
- Non-numeric values (skip them)
- Return float rounded to 2 decimal places"
Include test cases in your prompt.
Example:
"Create a function that converts temperature between Celsius and Fahrenheit.
Test cases:
- convert_temp(0, 'C', 'F') should return 32
- convert_temp(100, 'C', 'F') should return 212
- convert_temp(32, 'F', 'C') should return 0
- Invalid unit should raise ValueError"
Specify technical constraints upfront.
Example:
"Implement a rate limiter for API endpoints with these constraints:
- No external dependencies (pure Python)
- Thread-safe implementation
- Configurable time window and request limit
- Memory efficient for up to 10,000 users
- O(1) time complexity for checking limits"
Request documentation alongside code.
Example:
"Create a data validation module:
1. First, write comprehensive docstrings
2. Include parameter types and return types
3. Add usage examples in docstrings
4. Then implement the actual functions
5. Include inline comments for complex logic"
Scenario: A retail company needs to analyze daily sales performance across multiple product categories.
Prompt:
"I need to process CSV files containing sales data.
Create a Python function that:
- Reads a CSV file with columns: date, product, quantity, price
- Filters records from the last 30 days
- Calculates total revenue per product
- Returns a dictionary with product names as keys and revenue as values
- Handle missing or invalid data gracefully"
Industry Impact: This automation saves 2-3 hours of manual Excel work daily and provides real-time insights for inventory decisions.
Scenario: A logistics company needs weather data to optimize delivery routes and warehouse operations.
Prompt:
"Create a wrapper class for the OpenWeather API:
- Use requests library
- Implement methods for current weather and 5-day forecast
- Cache responses for 10 minutes to avoid rate limits
- Handle API errors with custom exceptions
- Include retry logic with exponential backoff
- Return data as Python dictionaries"
Business Value: Reduces API costs by 70% through caching and prevents service disruptions with proper error handling.
Scenario: An automated warehouse system needs efficient pathfinding for robot navigation between storage locations.
Prompt:
"Implement the A* pathfinding algorithm for a 2D grid:
- Grid cells can be walkable (0) or obstacles (1)
- Use Manhattan distance for heuristic
- Return list of coordinates from start to end
- If no path exists, return empty list
- Optimize for performance with large grids (1000x1000)
- Include visualization method that prints the path on the grid"
Production Benefit: Reduces robot travel time by 35% compared to basic navigation, increasing warehouse throughput.
How to know if your prompt is effective:
Problem: The generated code is missing important functionality or error handling.
Solution:
Prevention: Use the CLEAR framework to ensure all aspects are covered before submitting your prompt.
Problem: AI generates code in Python 2 when you need Python 3, or uses outdated libraries.
Solution:
Prevention: Include language and version in every prompt as a standard practice.
Problem: AI provides unnecessarily complicated code for simple tasks.
Solution:
Prevention: Include complexity preferences in your initial prompt.
Problem: Generated code fails on edge cases like empty inputs or null values.
Solution:
Prevention: Always include a "Handle edge cases" requirement in your prompts.
In the next lesson, you'll learn:
Remember: Prompt engineering is a skill that improves with practice. Each interaction with AI teaches you how to communicate more effectively for better results!