When AI assistants repeatedly modify code without human oversight, code quality erodes through accumulated micro-decisions

TL;DR: You let repeated AI edits slowly distort your code’s meaning

Problems 😔

• Unclear intent
• Naming drift
• Readability
• Lost domain terms
• Duplicated logic
• Generic abstractions
• Model collapse
• Semantic decay
• Code entropy accumulation
• Lost domain knowledge
• Degraded naming clarity
• Architectural drift
• Code inbreeding
• Technical debt buildup
• Semantic meaning loss

Solutions 😃

1. Preserve domain-specific language
2. Review every AI change
3. Write golden tests
4. Introduce small objects
5. Reject unclear edits in merge requests and code reviews
6. Fight workslop code

Refactorings ⚙️

Context 💬

When you let AI assistants modify code repeatedly without critical human review, you create a degradation pattern similar to model collapse in machine learning.

Each iteration introduces small deviations from best practices.

The AI optimizes for immediate problem-solving rather than long-term maintainability.

Variable names become generic.

You use comments as an excuse to replace clear code.

Functions grow longer.

Domain concepts blur into technical implementations.

The codebase transforms into AI slop: technically functional but semantically hollow code.

You request simple changes: rename something, extract something, improve clarity.

Each iteration shifts names, removes nuance, and replaces domain words with generic ones.

Your code no longer accurately reflects the real-world domain.

You lose the shape of the system.

This is slow erosion.

Sample Code 📖

Wrong ❌

def process_data(d, t='standard'):
"""Process customer data"""
if t == 'standard':
result = []
for item in d:
if item.get('status') == 'active':
temp = item.copy()
temp['processed'] = True
total = 0
for x in temp.get('items', []):
total += x.get('price', 0)
temp['total'] = total
result.append(temp)
return result
elif t == 'premium':
result = []
for item in d:
if item.get('status') == 'active' and \
item.get('tier') == 'premium':
temp = item.copy()
temp['processed'] = True
total = 0
for x in temp.get('items', []):
total += x.get('price', 0) * 0.9
temp['total'] = total
result.append(temp)
return result
return []

Right 👉

class CustomerOrder:
def __init__(self, customer, items, status):
self._customer = customer
self._items = items
self._status = status

def is_active(self):
return self._status.is_active()

def calculate_total(self):
return self._customer.apply_pricing_tier(
sum(item.price() for item in self._items)
)

def mark_as_processed(self):
return ProcessedOrder(self, self.calculate_total())

class OrderProcessor:
def process_active_orders(self, orders):
return [
order.mark_as_processed()
for order in orders
if order.is_active()
]

Detection 🔍

[X] Manual

You can detect AI-degraded code by reviewing commit history for patterns: consecutive AI-assisted commits without human refactoring, increasing function length over time, proliferation of generic variable names (data, temp, result, item), growing comment-to-code ratio, and duplicated logic with minor variations.

Code review tools can track these metrics and flag potential degradation.

Exceptions 🛑

AI assistance remains valuable for boilerplate generation, test case creation, and initial prototyping when you immediately review and refactor the output.

The smell appears when you chain multiple AI modifications without human intervention or when you accept AI suggestions without understanding their implications.

Tags 🏷️

• Technical Debt

Level 🔋

[x] Intermediate

Why the Bijection Is Important 🗺️

Your code should maintain a clear Bijection between domain concepts in the MAPPERand your implementation.

When AI assistants modify code without understanding your domain, they break this mapping.

A “Customer” becomes “data”, an “Order” becomes “item”, and “apply pricing tier” becomes “calculate total with discount”.

You lose the vocabulary that connects your code to business reality.

Each AI iteration moves further from domain language toward generic programming constructs, making the code harder to understand and maintain.

AI Generation 🤖

AI generators frequently create this smell when you prompt them to modify existing code multiple times.

Each interaction optimizes for the immediate request without considering the cumulative architectural impact.

The AI suggests quick fixes that work but don’t align with your codebase’s design patterns or domain model.

AI assistants tend to replace domain language with generic language.

They optimize for pattern consistency instead of meaning.

They smooth away intent.

AI Detection 🧲

AI can address this issue if you instruct it to restore domain terms and request that it explain its naming choices.

You are accountable for the work you delegate to the AI, and you must approve every change.

Try Them! 🛠

Remember: AI Assistants make lots of mistakes

Suggested Prompt: “Review this code for domain clarity. Replace generic names with domain concepts. Extract duplicated logic into cohesive objects. Ensure each class and method represents a clear business concept. Show me the domain model this code implements.”

Without Proper Instructions	With Specific Instructions
ChatGPT	ChatGPT
Claude	Claude
Perplexity	Perplexity
Copilot	Copilot
You	You
Gemini	Gemini
DeepSeek	DeepSeek
Meta AI	Meta AI
Grok	Grok
Qwen	Qwen

Conclusion 🏁

The “Habsburg problem” analogy in AI, also called “Habsburg AI,” refers to how AI models can degrade when repeatedly trained on content generated primarily by other AI models, like the inbreeding issues suffered by the Habsburg royal family.

This causes a loss of diversity and robustness in the AI’s outputs, eventually leading AI’s responses to become progressively worse or semantically hollow.

You must actively review and refactor AI-generated code to maintain quality.

Treat AI assistants as junior developers whose work requires supervision.

Each AI suggestion should strengthen your domain model, not weaken it. When you notice generic patterns replacing domain language, stop and refactor.

Your code’s long-term maintainability depends on preserving the connection between business concepts and implementation.

Relations 👩‍❤️‍💋‍👨

More Information 📕

Model Collapse from Wikipedia

House of Hausburg from Wikipedia

Disclaimer 📘

Code Smells are my opinion.

---

Code is design

Ward Cunningham

---

This article is part of the CodeSmell Series.