Best AI Code Generation Models Compared

import anthropic

client = anthropic.Anthropic()

def generate_code(task: str, codebase_context: str = "") -> str:
    """Generate code using Claude Opus 4 with extended thinking."""
    messages = [
        {
            "role": "user",
            "content": f"""You are a senior software engineer.

Context from the codebase:
{codebase_context}

Task: {task}

Requirements:
- Write production-quality code with error handling
- Follow existing code patterns from the context
- Include type hints and docstrings
- Add inline comments for non-obvious logic"""
        }
    ]

    # Use extended thinking for complex tasks
    response = client.messages.create(
        model="claude-opus-4-20250115",
        max_tokens=16000,
        thinking={
            "type": "enabled",
            "budget_tokens": 10000  # Let the model reason deeply
        },
        messages=messages
    )

    # Extract the text response (thinking is internal)
    for block in response.content:
        if block.type == "text":
            return block.text
    return ""

# Example: Generate a REST API endpoint
code = generate_code(
    task="Create a FastAPI endpoint for user registration with email validation, "
         "password hashing, and duplicate detection",
    codebase_context="# Using FastAPI 0.109+, SQLAlchemy 2.0, Pydantic v2"
)
print(code)

from openai import OpenAI

client = OpenAI()

def generate_code(task: str, language: str = "python") -> str:
    """Generate code using GPT-5 with structured output."""
    response = client.chat.completions.create(
        model="gpt-5",
        messages=[
            {
                "role": "system",
                "content": f"You are an expert {language} developer. "
                           "Generate clean, production-ready code. "
                           "Include error handling and type annotations."
            },
            {
                "role": "user",
                "content": task
            }
        ],
        temperature=0,
        max_tokens=4096,
    )
    return response.choices[0].message.content

# Using with structured outputs for code + explanation
from pydantic import BaseModel

class CodeResponse(BaseModel):
    code: str
    language: str
    explanation: str
    complexity: str  # O(n), O(n log n), etc.
    edge_cases: list[str]

response = client.beta.chat.completions.parse(
    model="gpt-5",
    messages=[
        {
            "role": "system",
            "content": "Generate code and analysis in the required format."
        },
        {
            "role": "user",
            "content": "Implement a thread-safe LRU cache with TTL support in Python"
        }
    ],
    response_format=CodeResponse,
)

result = response.choices[0].message.parsed
print(f"Complexity: {result.complexity}")
print(f"Edge cases: {result.edge_cases}")
print(result.code)

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

def generate_code(task: str, thinking: bool = True) -> str:
    """Generate code using Gemini 2.5 Pro with thinking mode."""
    model = genai.GenerativeModel("gemini-2.5-pro-preview-03-25")

    # Enable thinking for complex algorithmic problems
    config = genai.GenerationConfig(
        temperature=0,
        max_output_tokens=8192,
    )
    if thinking:
        config.thinking_config = {"thinking_budget": 8000}

    response = model.generate_content(
        f"""Solve this programming problem step by step.

{task}

Provide:
1. Your approach and reasoning
2. Clean, optimized code
3. Time and space complexity analysis
4. Test cases covering edge cases""",
        generation_config=config
    )

    return response.text

# Leverage 1M context for codebase analysis
def analyze_codebase(files: dict[str, str], question: str) -> str:
    """Analyze an entire codebase using Gemini's 1M context."""
    model = genai.GenerativeModel("gemini-2.5-pro-preview-03-25")

    context = "\n\n".join(
        f"--- {path} ---\n{content}"
        for path, content in files.items()
    )

    response = model.generate_content(
        f"""Here is a complete codebase:\n\n{context}\n\n
Question: {question}
Provide a detailed answer referencing specific files and line numbers.""",
        generation_config=genai.GenerationConfig(temperature=0)
    )

    return response.text

# Example: competitive programming
solution = generate_code(
    "Given an array of integers, find the longest increasing subsequence. "
    "The solution must run in O(n log n) time."
)
print(solution)

from openai import OpenAI

# DeepSeek uses OpenAI-compatible API
client = OpenAI(
    api_key="YOUR_DEEPSEEK_KEY",
    base_url="https://api.deepseek.com"
)

def generate_code(task: str) -> str:
    """Generate code using DeepSeek-V3 (671B MoE)."""
    response = client.chat.completions.create(
        model="deepseek-chat",  # Points to DeepSeek-V3
        messages=[
            {
                "role": "system",
                "content": "You are an expert programmer. Write clean, "
                           "efficient code with comprehensive error handling."
            },
            {
                "role": "user",
                "content": task
            }
        ],
        temperature=0,
        max_tokens=4096,
        stream=False
    )
    return response.choices[0].message.content

# Self-hosted via vLLM for maximum privacy
# pip install vllm
# vllm serve deepseek-ai/DeepSeek-V3 --tensor-parallel-size 8

def generate_code_self_hosted(task: str) -> str:
    """Generate code using self-hosted DeepSeek-V3."""
    local_client = OpenAI(
        api_key="not-needed",
        base_url="http://localhost:8000/v1"
    )
    response = local_client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V3",
        messages=[{"role": "user", "content": task}],
        temperature=0,
        max_tokens=4096
    )
    return response.choices[0].message.content

# Example
code = generate_code(
    "Implement a B-tree with insert, search, and delete operations in Python"
)
print(code)

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# Qwen2.5-Coder-32B - best code-specific open-source model
model_name = "Qwen/Qwen2.5-Coder-32B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",  # Automatic multi-GPU placement
    trust_remote_code=True
)

def generate_code(task: str) -> str:
    """Generate code using Qwen2.5-Coder-32B."""
    messages = [
        {"role": "system", "content": "You are an expert programmer."},
        {"role": "user", "content": task}
    ]

    text = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )
    inputs = tokenizer(text, return_tensors="pt").to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=4096,
            do_sample=False,
            num_beams=1
        )

    response = tokenizer.decode(
        outputs[0][inputs.input_ids.shape[1]:],
        skip_special_tokens=True
    )
    return response

# For production: serve with vLLM
# vllm serve Qwen/Qwen2.5-Coder-32B-Instruct --tensor-parallel-size 2

# Fine-tuning on your codebase (key advantage)
# Use unsloth for efficient fine-tuning:
# pip install unsloth
#
# from unsloth import FastLanguageModel
# model, tokenizer = FastLanguageModel.from_pretrained(
#     "Qwen/Qwen2.5-Coder-32B-Instruct",
#     max_seq_length=8192,
#     load_in_4bit=True,
# )
# model = FastLanguageModel.get_peft_model(model, r=16, target_modules=[...])

code = generate_code(
    "Write a Python decorator that implements circuit breaker pattern "
    "with configurable failure threshold, reset timeout, and half-open state"
)
print(code)

from mistralai import Mistral

client = Mistral(api_key="YOUR_MISTRAL_KEY")

def generate_code(task: str) -> str:
    """Generate code using Codestral 25.01."""
    response = client.chat.complete(
        model="codestral-latest",
        messages=[
            {
                "role": "user",
                "content": task
            }
        ],
        temperature=0,
        max_tokens=4096
    )
    return response.choices[0].message.content

# Fill-in-the-Middle (FIM) - Codestral's killer feature
def code_completion(prefix: str, suffix: str) -> str:
    """Use FIM for intelligent code completion."""
    response = client.fim.complete(
        model="codestral-latest",
        prompt=prefix,
        suffix=suffix,
        temperature=0,
        max_tokens=512
    )
    return response.choices[0].message.content

# Example: FIM for autocomplete
prefix = '''def binary_search(arr: list[int], target: int) -> int:
    """Find target in sorted array. Returns index or -1."""
    left, right = 0, len(arr) - 1
    while left <= right:
'''

suffix = '''
    return -1

# Tests
assert binary_search([1, 3, 5, 7, 9], 5) == 2
assert binary_search([1, 3, 5, 7, 9], 4) == -1
'''

middle = code_completion(prefix, suffix)
print(f"Generated middle:\n{middle}")