07 - Generative AI for Software Development: Code Generation and AI Assistants

# Level 1: In-line autocomplete
# Write a comment or start of a function, AI completes
def calculate_compound_interest(principal, rate, time, n=12):
    """Calculate compound interest with monthly compounding.

    Args:
        principal: Initial investment amount
        rate: Annual interest rate (as decimal, e.g., 0.05 for 5%)
        time: Time in years
        n: Number of compounding periods per year

    Returns:
        Final amount after compound interest
    """
    # AI automatically generates:
    amount = principal * (1 + rate / n) ** (n * time)
    interest = amount - principal
    return {
        "final_amount": round(amount, 2),
        "interest_earned": round(interest, 2),
        "total_return_pct": round((interest / principal) * 100, 2)
    }


# Level 2: Generation from docstring
# Describe what you want in the docstring, AI implements
def validate_italian_fiscal_code(fiscal_code: str) -> dict:
    """Validate an Italian fiscal code (codice fiscale).

    Checks:
    - Length is exactly 16 characters
    - Format matches pattern: 6 letters + 2 digits + 1 letter + 2 digits + 1 letter + 3 digits + 1 letter
    - Check character is valid using MOD 26 algorithm

    Returns dict with 'valid' bool and 'errors' list.
    """
    # AI generates the complete implementation based on the docstring
    errors = []
    fiscal_code = fiscal_code.upper().strip()

    if len(fiscal_code) != 16:
        errors.append(f"Length must be 16, got {len(fiscal_code)}")

    import re
    pattern = r'^[A-Z]{6}[0-9]{2}[A-Z][0-9]{2}[A-Z][0-9]{3}[A-Z]$'
    if not re.match(pattern, fiscal_code):
        errors.append("Format does not match expected pattern")

    return {"valid": len(errors) == 0, "errors": errors}
      

# Prompt to generate comprehensive tests
# "Generate pytest tests for the calculate_compound_interest function"

import pytest

class TestCalculateCompoundInterest:
    """AI-generated test suite for calculate_compound_interest."""

    def test_basic_calculation(self):
        """Test with standard values."""
        result = calculate_compound_interest(1000, 0.05, 1)
        assert result["final_amount"] == 1051.16
        assert result["interest_earned"] == 51.16

    def test_zero_principal(self):
        """Test with zero initial investment."""
        result = calculate_compound_interest(0, 0.05, 1)
        assert result["final_amount"] == 0
        assert result["interest_earned"] == 0

    def test_zero_rate(self):
        """Test with zero interest rate."""
        result = calculate_compound_interest(1000, 0, 5)
        assert result["final_amount"] == 1000
        assert result["interest_earned"] == 0

    def test_multiple_years(self):
        """Test over multi-year period."""
        result = calculate_compound_interest(10000, 0.08, 10)
        assert result["final_amount"] > 10000
        assert result["total_return_pct"] > 100  # More than doubled in 10 years

    def test_custom_compounding(self):
        """Test with custom compounding (quarterly)."""
        result = calculate_compound_interest(1000, 0.12, 1, n=4)
        assert result["final_amount"] == 1125.51

    def test_high_rate(self):
        """Test with high rate."""
        result = calculate_compound_interest(1000, 1.0, 1)
        assert result["final_amount"] > 2000
      

# Example: asking AI for a code review
# Prompt: "Review this function, identify issues and suggest improvements"

# Original code (with problems)
def get_user_data(user_id):
    import requests
    r = requests.get(f"https://api.example.com/users/{user_id}")
    data = r.json()
    name = data["name"]
    email = data["email"]
    return name, email

# AI identifies:
# 1. Import inside function (move to top)
# 2. No HTTP error handling
# 3. No request timeout
# 4. No input validation
# 5. Tuple return (better dict or dataclass)
# 6. No type hints

# AI-suggested improved version:
from dataclasses import dataclass
import requests
from requests.exceptions import RequestException

@dataclass
class UserData:
    name: str
    email: str

def get_user_data(user_id: int) -> UserData:
    """Fetch user data from the API.

    Args:
        user_id: The unique identifier of the user.

    Returns:
        UserData object with name and email.

    Raises:
        ValueError: If user_id is invalid.
        RequestException: If API call fails.
    """
    if not isinstance(user_id, int) or user_id <= 0:
        raise ValueError(f"Invalid user_id: {user_id}")

    try:
        response = requests.get(
            f"https://api.example.com/users/{user_id}",
            timeout=10
        )
        response.raise_for_status()
        data = response.json()
        return UserData(name=data["name"], email=data["email"])
    except RequestException as e:
        raise RequestException(f"Failed to fetch user {user_id}: {e}") from e
      

# Patterns for effective AI use in development

# 1. Skeleton + AI Fill: write the structure, AI fills in
class OrderProcessor:
    """Process e-commerce orders with validation and notifications."""

    def validate_order(self, order: dict) -> bool:
        # AI implements complete validation
        pass

    def calculate_total(self, items: list, discount_code: str = None) -> float:
        # AI implements calculation with discounts
        pass

    def send_confirmation(self, order_id: str, email: str) -> bool:
        # AI implements email sending
        pass


# 2. Test-First + AI Implementation
# Write tests first, then ask AI to implement
def test_order_validation():
    """These tests define expected behavior."""
    processor = OrderProcessor()
    assert processor.validate_order({"items": [{"id": 1, "qty": 2}]}) == True
    assert processor.validate_order({"items": []}) == False
    assert processor.validate_order({}) == False
    # "Implement OrderProcessor.validate_order to pass these tests"