TL;DR: Don't waste time refactoring code that never changes; focus on frequently modified problem areas.
Problems π
- Wasted effort
- Wrong priorities
- Missed real issues
- Team productivity drop
- Resource misallocation
- False progress feeling
Solutions π
- Analyze change frequency
- Identify code hotspots
- Use version control data
- Focus on active areas
- Measure code churn
Refactorings βοΈ
Context π¬
This is the anti code smell.
You come across ugly code with complex conditionals, long functions, and poor naming.
You remember Uncle Bob's motto of leaving the campsite better than when you found it.
Your refactoring instinct kicks in, and you spend days cleaning it up.
You feel productive, but you've wasted your time.
Bad code is only problematic when you need to change it.
Stable code, even when poorly written, doesn't hurt your productivity.
The real technical debt lies in code hotspots: areas that are both problematic and frequently modified.
Most codebases follow an extreme distribution where 5% of the code receives 90% of the changes.
Without analyzing version control history, you cannot identify which messy code actually matters.
You end up fixing the wrong things while the real problems remain untouched.
You need to address the technical debt by prioritizing code with poor quality and high change frequency.
Everything else is premature optimization disguised as craftsmanship.
Sample Code π
Wrong β
class LegacyAuthenticator:
def authenticate(self, user, pwd):
if user != None:
if pwd != None:
if len(pwd) > 5:
result = self.check_db(user, pwd)
if result == True:
return True
else:
return False
return False
class LegacyAuthenticator:
def authenticate(self, user: str, pwd: str) -> bool:
if not self._is_valid_input(user, pwd):
return False
return self._verify_credentials(user, pwd)
def _is_valid_input(self, user: str, pwd: str) -> bool:
return user and pwd and len(pwd) > 5
def _verify_credentials(self, user: str, pwd: str) -> bool:
return self.check_db(user, pwd)
Right π
class PaymentProcessor:
def process_payment(self, amount, card, user, promo_code,
installments, currency, gateway):
pass
class LegacyAuthenticator:
def authenticate(self, user, pwd):
if user != None:
if pwd != None:
if len(pwd) > 5:
result = self.check_db(user, pwd)
if result == True:
return True
return False
Detection π
[X] Semi-Automatic
You can detect this smell by analyzing your version control history.
Track which files change most frequently and correlate that with code quality metrics.
Tools like CodeScene, git log analysis, or custom scripts can show your actual hotspots.
Track your defects to the code you change more often.
Exceptions π
Sometimes you must refactor stable code when:
- New feature development requires adaptive changes
- Security vulnerabilities require fixes
- Regulatory compliance demands changes
- You're about to reactivate dormant features
The key is intentional decision-making based on real data, not assumptions.
Level π
[X] Intermediate
Why the Bijection Is Important πΊοΈ
While you build a MAPPER between your code and real-world behavior, you will notice some parts of your system are more actively changed than others.
Your bijection should reflect this reality.
When you refactor stable code, you break the correspondence between development effort and actual business value.
You treat all code equally in your mental model, but the real world shows extreme usage patterns: a small percentage of code handles the vast majority of changes.
You optimize for an imaginary world where all code matters equally.
AI Generation π€
Some code generators suggest refactorings without considering change frequency.
AI tools and linters analyze code statically and recommend improvements based on patterns alone and not usage.
They do not access your version control history to understand which improvements actually matter unless you explicitly tell them to do it.
AI might flag every long function or complex conditional, treating a dormant 500-line legacy method the same as an equally messy function you modify daily.
AI Detection π§²
AI can help fix this smell if you provide proper context.
You need to give it version control data showing change frequencies. Without that information, AI will make the same mistakes humans do: recommending refactorings based purely on code structure.
Try Them! π
Remember: AI Assistants make lots of mistakes
Suggested Prompt: Analyze this codebase's git history to identify files with high change frequency. Then review code quality metrics for those files. Recommend refactoring only the intersection of high-churn and low-quality code. Ignore stable low-quality code."
Conclusion π
You cannot improve productivity by polishing code that never changes.
Technical debt only matters when it slows you down, which happens in code you actually modify.
Focus your refactoring efforts where they multiply your impact: the hotspots where poor quality meets frequent change.
Everything else is procrastination disguised as engineering excellence.
Let stable ugly code rest in peace.
Your human time is too valuable to waste on problems that don't exist.
Relations π©ββ€οΈβπβπ¨
Disclaimer π
Code Smells are my opinion.
Credits π
Photo by Viktor Keri on Unsplash
The first rule of optimization is: Don't do it. The second rule is: Don't do it yet.
Michael A. Jackson
This article is part of the CodeSmell Series.
