Code Generation Cheat Sheet — LLM Patterns & Pitfalls

from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

prompt = """You are a Python expert. Generate a function following this pattern.

Examples:
def calculate_tax(amount: float) -> float:
    """Calculate 8% sales tax."""
    return amount * 0.08

def apply_discount(price: float, rate: float) -> float:
    """Apply discount as percentage."""
    return price * (1 - rate / 100)

Now write a function that:
- Takes a list of numbers
- Returns the sum after removing outliers (>2 std devs)
- Include docstring and type hints"""

response = client.chat.completions.create(
    model="gpt-4o",
    temperature=0.3,
    messages=[{"role": "user", "content": prompt}]
)

generated_code = response.choices[0].message.content
print(generated_code)

import json
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

schema = {
    "type": "object",
    "properties": {
        "function_name": {"type": "string"},
        "parameters": {
            "type": "array",
            "items": {"type": "object", "properties": {"name": {"type": "string"}, "type": {"type": "string"}}}
        },
        "body": {"type": "string", "description": "Python code body"}
    }
}

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Generate a function to validate email addresses."}],
    response_format={"type": "json_schema", "json_schema": {"name": "function_spec", "schema": schema}}
)

spec = json.loads(response.choices[0].message.content)
print(f"Function: {spec['function_name']}")
for param in spec['parameters']:
    print(f"  {param['name']}: {param['type']}")

from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

prompt = """Write a function to find the longest increasing subsequence in an array.

Before writing code:
1. Explain the algorithm
2. Describe the data structure
3. Identify edge cases
4. Then write the implementation

Requirements:
- Time complexity: O(n log n) or better
- Handle empty arrays
- Return indices and values"""

response = client.chat.completions.create(
    model="gpt-4o",
    temperature=0.2,
    messages=[{"role": "user", "content": prompt}]
)

output = response.choices[0].message.content
print(output)

from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Read existing code as context
with open("db_utils.py") as f:
    existing_code = f.read()

prompt = f"""Review this existing code and generate a new function in the same style:

```python
{existing_code}
```

Add a function to:
- Connect to Redis with timeout and retry logic
- Match the error handling pattern above
- Use the same logging setup
- Include docstrings like the existing functions"""

response = client.chat.completions.create(
    model="gpt-4o",
    temperature=0.2,
    messages=[{"role": "user", "content": prompt}]
)

generated = response.choices[0].message.content
print(generated)

import ast
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def generate_and_validate(spec: str, max_retries: int = 3) -> str:
    for attempt in range(max_retries):
        response = client.chat.completions.create(
            model="gpt-4o",
            temperature=0.2,
            messages=[{"role": "user", "content": f"Generate Python code: {spec}"}]
        )
        
        code = response.choices[0].message.content
        
        # Extract code block if wrapped
        if "```python" in code:
            code = code.split("```python")[1].split("```")[0]
        
        # Validate syntax
        try:
            ast.parse(code)
            return code
        except SyntaxError as e:
            if attempt < max_retries - 1:
                print(f"Syntax error (attempt {attempt + 1}): {e}")
                continue
            else:
                raise ValueError(f"Failed after {max_retries} attempts: {e}")
    
    return code

result = generate_and_validate("Write a function to parse CSV with type inference")
print(result)