Have you noticed your AI coding assistant getting… weird lately? Maybe it’s generating code that feels oddly repetitive, or producing solutions that work but seem unnecessarily convoluted. You’re not imagining things, and you’re definitely not alone.

We’re witnessing something fascinating and troubling in real-time: AI model collapse in code generation. It’s happening because models are increasingly training on code that was itself generated by AI, creating a feedback loop that’s slowly degrading the quality of outputs. Think of it like making photocopies of photocopies – each generation gets a little blurrier.

What Exactly Is AI Model Collapse?

Model collapse occurs when AI systems train on data generated by other AI systems, leading to a gradual degradation in output quality and diversity. In the coding world, this means AI models are learning from Stack Overflow answers, GitHub repositories, and documentation that was written by other AI models.

The problem is particularly acute with code because AI-generated code often has subtle patterns and quirks that humans might not notice but that become amplified when fed back into training data. I’ve been tracking this phenomenon for months, and the signs are becoming impossible to ignore.

Here’s a simple example I’ve observed. Early GPT models might generate a function like this:

def calculate_average(numbers):
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)

But newer models trained on AI-contaminated data often produce unnecessarily verbose versions:

def calculate_average(numbers):
    # Check if the input list is empty
    if not numbers:
        # Return 0 for empty list as per common convention
        return 0
    
    # Calculate sum of all numbers
    total_sum = sum(numbers)
    # Calculate count of numbers
    count = len(numbers)
    # Return the average
    return total_sum / count

The second version isn’t wrong, but it’s showing the hallmarks of AI training on AI-generated content: excessive verbosity, redundant comments, and patterns that feel artificially structured.

The Contamination Feedback Loop

The cycle works like this: AI generates code → humans use and modify that code → the modified code gets uploaded to public repositories → new AI models train on those repositories → the next generation of AI produces slightly degraded outputs → repeat.

What makes this particularly insidious is that the degradation is gradual. Each generation is only slightly worse than the last, making it hard to detect until you’re several cycles deep. By then, you’ve got models that produce functional but increasingly suboptimal code.

I’ve noticed some telltale signs in my own work:

  • More boilerplate code than necessary
  • Overly defensive programming patterns
  • Comments that explain obvious operations
  • Function naming that’s technically correct but feels unnatural

The scary part? This isn’t just affecting code quality – it’s affecting how we think about code. When junior developers learn from AI-generated examples that are already several generations removed from human-written code, they’re absorbing these degraded patterns as “best practices.”

Detecting AI-Generated Code in Your Workflow

So how do we fight back? The first step is detection. I’ve been experimenting with several approaches to identify potentially AI-generated code, both in my own projects and in dependencies I’m considering.

Pattern Recognition Scripts

Here’s a simple Python script I use to flag suspicious patterns:

import re
from collections import Counter

def analyze_code_patterns(code_text):
    """Detect patterns common in AI-generated code"""
    
    suspicious_patterns = {
        'excessive_comments': len(re.findall(r'#.*', code_text)),
        'verbose_variable_names': len([word for word in re.findall(r'\b\w+\b', code_text) 
                                     if len(word) > 15]),
        'redundant_checks': code_text.count('if not') + code_text.count('is None'),
        'defensive_patterns': code_text.count('try:') + code_text.count('except:')
    }
    
    # Calculate suspicion score
    score = sum(suspicious_patterns.values()) / max(len(code_text.split('\n')), 1)
    
    return score, suspicious_patterns

# Usage example
with open('suspicious_file.py', 'r') as f:
    code = f.read()
    
score, patterns = analyze_code_patterns(code)
if score > 0.3:  # Threshold based on my observations
    print(f"High AI probability: {score:.2f}")
    print("Suspicious patterns:", patterns)

Entropy Analysis

AI-generated code often has lower entropy than human-written code. Humans make seemingly random choices in variable naming, formatting, and structure. AI models, even when trying to be creative, fall into predictable patterns.

import math
from collections import Counter

def calculate_code_entropy(code_text):
    """Calculate entropy of code structure"""
    
    # Tokenize the code (simplified)
    tokens = re.findall(r'\b\w+\b|[^\w\s]', code_text.lower())
    token_counts = Counter(tokens)
    
    # Calculate entropy
    total_tokens = len(tokens)
    entropy = -sum((count/total_tokens) * math.log2(count/total_tokens) 
                   for count in token_counts.values())
    
    return entropy

# Lower entropy often indicates AI generation
entropy = calculate_code_entropy(code)
print(f"Code entropy: {entropy:.2f}")

Repository-Level Analysis

For larger codebases, I look at commit patterns and code evolution:

# Check for sudden style changes in git history
git log --oneline --name-only | head -100 | 
while read line; do
    if [[ $line == *.py ]]; then
        echo "Checking $line for style consistency..."
        # Run your detection scripts on different versions
    fi
done

Building Resistance Into Your Development Process

Detection is just the first step. Here’s how I’ve adapted my workflow to minimize contamination:

Diversify Your Training Sources: When learning new patterns, I deliberately seek out pre-2020 code examples and established open-source projects with long histories. The Linux kernel, PostgreSQL, and other mature projects are goldmines of human-written code.

Human-First Code Reviews: I’ve started flagging any code that feels “too clean” or follows patterns I commonly see from AI assistants. Sometimes the messy, imperfect solution is actually more maintainable in the long run.

Entropy Injection: This sounds weird, but I deliberately introduce small amounts of randomness into my coding style – different variable naming conventions, varying levels of comments, mixing functional and object-oriented approaches where appropriate.

The goal isn’t to make code worse, but to maintain the diversity and creativity that makes codebases resilient and maintainable.

The Path Forward

Model collapse isn’t inevitable, but it requires conscious effort to prevent. The companies training these models are starting to recognize the problem – OpenAI and Anthropic have both published research on contamination detection. But as individual developers, we can’t wait for the big players to solve this.

Start by running detection scripts on your critical dependencies. Question code that feels too perfect or follows patterns you’ve seen repeated across multiple AI tools. Most importantly, keep learning from human-written code and human mentors.

The future of AI-assisted development depends on maintaining that crucial human element in our training data. We’re not just writing code – we’re teaching the next generation of AI what good code looks like.

What patterns have you noticed in your AI coding tools? I’d love to hear about your own detection techniques and whether you’ve spotted signs of model degradation in your workflow.