Search for a command to run...
When AI assistants repeatedly modify code without human oversight, code quality erodes through accumulated micro-decisions
I’m a senior software engineer loving clean code, and declarative designs. S.O.L.I.D. and agile methodologies fan.
No comments yet. Be the first to comment.
In this series, we will see several symptoms and situations that make us doubt the quality of our developments. We will present possible solutions. Most are just clues. They are no hard rules.
When AI Fills the Gaps, You Should Think Through
Approve the logic once, then let it run the same way forever.
Different stages need different brains.
One Second Brain doesn't scale past one skull.
Style errors double when nobody enforces them.
Know who speaks before the skill runs TL;DR: Always define a clear role at the top of every skill file so you know whose perspective drives the execution. Common Mistake ❌ You write a skill full of
TL;DR: You let repeated AI edits slowly distort your code’s meaning
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.
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 []
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()
]
[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.
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.
[x] Intermediate
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 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 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.
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 |
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.
Code Smells are my opinion.
Code is design
Ward Cunningham
This article is part of the CodeSmell Series.