AI Prompt Templates for Developers: Code, Debug, and Document Faster

Prompt:

"Write [language] code that [specific functionality]. Requirements:

• Input: [describe input parameters and types]
• Output: [describe expected output]
• Constraints: [performance requirements, edge cases to handle]
• Style: [coding conventions, patterns to follow]

Include error handling for [specific error cases]. Add comments explaining the logic."

"Write Python code that validates email addresses using regex. Requirements:

• Input: string (email address to validate)
• Output: boolean (True if valid, False if not)
• Constraints: Must handle common edge cases (multiple @, missing domain, special characters)
• Style: Follow PEP 8, use type hints

Include error handling for None or empty string inputs. Add comments explaining the regex pattern."

Prompt:

"Explain this [language] code in detail:

[paste code]

Focus on:

• What the code does (high-level purpose)
• How it works (step-by-step logic)
• Why certain approaches were used
• Potential issues or edge cases

Explain like I'm a [your experience level] developer familiar with [related concepts]."

"Explain this JavaScript code in detail:

[code snippet with complex async/await and promise chaining]

Focus on:

• What the code does (high-level purpose)
• How the async/await pattern works here
• Why promises are chained this way
• Potential race conditions or error scenarios

Explain like I'm an intermediate developer familiar with callbacks but new to async/await."

Prompt:

"Help me debug this [language] code. Problem: [describe the bug]

Expected behavior: [what should happen]

Actual behavior: [what's happening instead]

Error message (if any): [paste error]

Code:

[paste relevant code]

Context: [relevant environment details, dependencies, data]

Identify the likely cause and suggest a fix with explanation."

"Help me debug this Python code. Problem: Function returns None instead of calculated value

Expected behavior: Should return the sum of all even numbers in the list

Actual behavior: Returns None

Error message: No error, just returns None

Code:

def sum_evens(numbers):
    total = 0
    for num in numbers:
        if num % 2 == 0:
            total += num
                    

Context: Python 3.9, calling with sum_evens([1, 2, 3, 4, 5])

Identify the likely cause and suggest a fix with explanation."

Prompt:

"Review this [language] code for:

• Bugs and potential errors
• Performance issues
• Security vulnerabilities
• Code quality and best practices
• Readability and maintainability

Code:

[paste code]

Provide specific suggestions for improvement with examples."

"Review this JavaScript code for:

• Bugs and potential errors
• Performance issues
• Security vulnerabilities (especially XSS)
• Code quality and best practices
• Readability and maintainability

Code:

function displayUserData(user) {
    document.getElementById('profile').innerHTML =
        '<h2>' + user.name + '</h2>' +
        '<p>' + user.bio + '</p>';
}
                    

Provide specific suggestions for improvement with examples."

Prompt:

"Write [documentation type] for this [language] code:

[paste code]

Include:

• Purpose and functionality
• Parameters (types, descriptions, defaults)
• Return value (type, description)
• Usage examples
• Edge cases and limitations

Format: [JSDoc/docstring/markdown/etc.]"

"Write JSDoc documentation for this JavaScript function:

function fetchUserData(userId, options = {}) {
    const { timeout = 5000, retries = 3 } = options;
    // implementation...
}
                    

Include:

• Purpose and functionality
• Parameters (types, descriptions, defaults)
• Return value (type, description)
• Usage examples (2-3 scenarios)
• Edge cases (network errors, invalid userId)

Format: JSDoc with @param, @returns, @example tags"

Prompt:

"Suggest refactoring improvements for this [language] code. Focus on:

• [Specific concern: performance/readability/maintainability]
• Reducing complexity
• Following [specific pattern or principle]

Code:

[paste code]

Show before/after examples with explanation of improvements."

"Suggest refactoring improvements for this Python code. Focus on:

• Readability and clarity
• Reducing nested conditionals
• Following Python best practices

Code:

def process_order(order):
    if order is not None:
        if order.items:
            if order.total > 0:
                if order.customer:
                    # process order
                    return True
    return False
                    

Show before/after examples with explanation of improvements."

Prompt:

"Generate [testing framework] unit tests for this [language] function:

[paste code]

Include test cases for:

• Normal/happy path scenarios
• Edge cases: [list specific edges]
• Error conditions: [list expected errors]
• Boundary values

Use descriptive test names and include assertions with clear messages."

"Generate Jest unit tests for this JavaScript function:

function calculateDiscount(price, discountPercent) {
    if (price <= 0 || discountPercent < 0 || discountPercent > 100) {
        throw new Error('Invalid input');
    }
    return price * (1 - discountPercent / 100);
}
                    

Include test cases for:

• Normal scenarios (various prices and discounts)
• Edge cases: zero price, zero discount, 100% discount
• Error conditions: negative price, negative discount, discount > 100
• Boundary values: very small and very large numbers

Use descriptive test names and include assertions with clear messages."

Prompt:

"Optimize this [language] code for [performance metric: speed/memory/etc.]:

[paste code]

Current performance: [describe current behavior]

Target: [describe desired performance]

Constraints: [any limitations]

Suggest optimizations with:

• Improved code
• Explanation of changes
• Expected performance improvement
• Trade-offs (if any)

"

"Optimize this Python code for speed:

def find_duplicates(numbers):
    duplicates = []
    for i in range(len(numbers)):
        for j in range(i + 1, len(numbers)):
            if numbers[i] == numbers[j] and numbers[i] not in duplicates:
                duplicates.append(numbers[i])
    return duplicates
                    

Current performance: O(n³) time complexity, slow on large lists

Target: Handle lists with 100,000+ elements efficiently

Constraints: Must preserve order of first occurrence

Suggest optimizations with improved code, explanation, expected improvement, and trade-offs."

Prompt:

"Write [language] code to integrate with [API name]. Requirements:

• Endpoint: [API endpoint]
• Method: [GET/POST/etc.]
• Authentication: [auth method]
• Request data: [describe payload]
• Response handling: [what to do with response]
• Error handling: [specific errors to handle]

Include retry logic for network failures and proper error messages."

"Write JavaScript code to integrate with Stripe payment API. Requirements:

• Endpoint: Create payment intent
• Method: POST
• Authentication: Bearer token (API key)
• Request data: amount (in cents), currency, customer ID
• Response handling: Extract client_secret and return to frontend
• Error handling: Invalid amount, authentication errors, network failures

Include retry logic (3 attempts) for network failures and proper error messages for each error type."

Prompt:

"[Write/Optimize] this SQL query for [database type]:

Goal: [what data you need]

Tables: [describe relevant tables and relationships]

Conditions: [filtering criteria]

Performance considerations: [table sizes, indexes, etc.]

[If optimizing: Current query: [paste query]]

Provide the query with explanation of approach and any index recommendations."

"Optimize this SQL query for PostgreSQL:

Goal: Get all orders with customer details for orders placed in the last 30 days

Tables: orders (1M rows), customers (100K rows), joined on customer_id

Conditions: order_date >= NOW() - INTERVAL '30 days'

Performance considerations: orders table has index on order_date, no index on customer_id

Current query:

SELECT * FROM orders o, customers c
WHERE o.customer_id = c.id
AND o.order_date >= NOW() - INTERVAL '30 days';
                    

Provide optimized query with explanation and index recommendations."