// Manually writing the same pattern over and over
app.get("/api/users/:id", async (req, res) => {
	try {
		const user = await User.findById(req.params.id)
		if (!user) {
			return res.status(404).json({ error: "User not found" })
		}
		res.json(user)
	} catch (error) {
		res.status(500).json({ error: error.message })
	}
})

// Comment: "Create a GET endpoint for user by ID with error handling"
// AI generates the complete implementation instantly

// Original function
function calculateDiscount(price: number, percentage: number): number {
	return price * (1 - percentage / 100)
}

// AI-generated comprehensive test suite
describe("calculateDiscount", () => {
	it("should calculate discount correctly", () => {
		expect(calculateDiscount(100, 10)).toBe(90)
	})

	it("should handle zero discount", () => {
		expect(calculateDiscount(100, 0)).toBe(100)
	})

	it("should handle 100% discount", () => {
		expect(calculateDiscount(100, 100)).toBe(0)
	})

	it("should handle decimal prices", () => {
		expect(calculateDiscount(99.99, 10)).toBeCloseTo(89.99, 2)
	})

	it("should throw error for negative percentage", () => {
		expect(() => calculateDiscount(100, -10)).toThrow()
	})

	it("should throw error for percentage > 100", () => {
		expect(() => calculateDiscount(100, 150)).toThrow()
	})
})

def process_user_data(user):
    if not user:
        log_error("No user provided")
        return None
    if not validate_user(user):
        log_error("Invalid user data")
        return None
    result = transform_user(user)
    log_success("User processed successfully")
    return result

def process_order_data(order):
    if not order:
        log_error("No order provided")
        return None
    if not validate_order(order):
        log_error("Invalid order data")
        return None
    result = transform_order(order)
    log_success("Order processed successfully")
    return result

def process_data(data, validator, transformer, data_type):
    """Generic data processing with validation and logging."""
    if not data:
        log_error(f"No {data_type} provided")
        return None

    if not validator(data):
        log_error(f"Invalid {data_type} data")
        return None

    result = transformer(data)
    log_success(f"{data_type.capitalize()} processed successfully")
    return result

def process_user_data(user):
    return process_data(user, validate_user, transform_user, "user")

def process_order_data(order):
    return process_data(order, validate_order, transform_order, "order")

/**
 * Processes a payment transaction
 * @param {Object} transaction - The transaction object
 * @param {number} transaction.amount - Payment amount in cents
 * @param {string} transaction.currency - ISO currency code
 * @param {string} transaction.customerId - Customer identifier
 * @param {string} transaction.paymentMethod - Payment method ID
 * @returns {Promise<Object>} Transaction result
 * @throws {ValidationError} If transaction data is invalid
 * @throws {PaymentError} If payment processing fails
 */
async function processPayment(transaction) {
	// AI generates comprehensive JSDoc from function signature
}

# Error:
TypeError: Cannot read property 'map' of undefined

# AI Explanation:
# The error occurs when trying to call .map() on an undefined value.
# This usually happens when:
# 1. API request hasn't resolved yet
# 2. Data structure doesn't match expectations
# 3. Missing null/undefined check

# Suggested Fix:
const items = data?.items || [];
return items.map(item => <Item key={item.id} {...item} />);

// Ask AI: "Explain this Rust code like I'm a JavaScript developer"

fn process_items<T>(items: Vec<T>) -> Vec<T>
where
    T: Clone + std::fmt::Display,
{
    items
        .into_iter()
        .filter(|item| item.to_string().len() > 0)
        .collect()
}

// AI Explanation:
// This is like a JavaScript function that:
// 1. Takes an array of any type (like TypeScript generics)
// 2. Filters out items with empty string representation
// 3. Returns a new array (like .filter() in JS)
// 4. T: Clone means items can be duplicated (like spread operator)
// 5. T: Display means items can be converted to strings

# Slow: O(n²) complexity
def find_duplicates(arr):
    duplicates = []
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j] and arr[i] not in duplicates:
                duplicates.append(arr[i])
    return duplicates

# Fast: O(n) complexity
def find_duplicates(arr):
    seen = set()
    duplicates = set()
    for item in arr:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)

-- Prompt: "Get users who signed up in the last 30 days and made at least one purchase"

SELECT DISTINCT u.id, u.name, u.email
FROM users u
INNER JOIN orders o ON u.id = o.user_id
WHERE u.created_at >= NOW() - INTERVAL '30 days'
  AND o.status = 'completed'
ORDER BY u.created_at DESC;

# AI-generated commit message from git diff
git commit -m "feat(auth): add OAuth2 authentication

- Implement OAuth2 flow with Google and GitHub providers
- Add user session management with JWT tokens
- Create middleware for protected routes
- Update authentication tests
- Add environment variables for OAuth credentials

Closes #123"

workflow:
  1_planning:
    - AI generates technical spec from requirements
    - Creates task breakdown
    - Estimates complexity

  2_implementation:
    - AI scaffolds basic structure
    - Developer adds business logic
    - AI suggests improvements

  3_testing:
    - AI generates test cases
    - Developer adds edge cases
    - AI reviews test coverage

  4_documentation:
    - AI generates API docs
    - Creates usage examples
    - Updates README

  5_review:
    - AI performs code review
    - Checks for security issues
    - Suggests optimizations