Common Code Smells

Let’s explore some of the most common code smells that developers encounter and how to address them. Code smells are indicators of potential issues in your codebase, and recognizing them can lead to better software quality. Here are 31 code smells you should be familiar with:



While comments are essential for documenting code, excessive or confusing comments can be problematic. If your code needs extensive comments to explain its logic, consider refactoring it to make it more self-explanatory.

2. Duplicate Code

Duplication is a common issue that leads to maintenance nightmares. Repeated code fragments should be extracted into reusable functions or classes.

3. Lazy Class

Lazy classes serve no purpose and can be safely removed. If a class lacks functionality or remains unused, consider deleting it.

4. Dead Code

Unused code segments clutter your project and confuse other developers. Regularly clean up dead code to keep your codebase lean.

5. Speculative Generality

Avoid overengineering by creating overly generic solutions. Only add abstractions when necessary, not preemptively.

6. Oddball Solution

Sometimes, developers come up with unconventional solutions that deviate from established patterns. While creativity is valuable, ensure that your solution aligns with best practices.


7. Large Class

Monolithic classes violate the Single Responsibility Principle. Split large classes into smaller, focused ones.

8. Long Method

Long methods are hard to read and maintain. Break them down into smaller functions with clear responsibilities.

9. Long Parameter List

Excessive parameters make method calls cumbersome. Consider using data structures (e.g., objects) to group related parameters.

10. Primitive Obsession

Relying too much on primitive data types (e.g., using strings for everything) leads to code smells. Replace them with custom classes when appropriate.

11. Data Clumps

When several data items consistently appear together, consider encapsulating them into a single object.


12. Switch Statements

Switch statements violate the Open-Closed Principle. Use polymorphism or other design patterns instead.

13. Temporary Field

Temporary fields are variables set but never used. Remove them to improve code clarity.

14. Refused Bequest

Inheritance hierarchies can lead to unwanted inherited behavior. Avoid inheriting methods or properties that don’t make sense in the subclass.

15. Alternative Classes with Different Interfaces

Similar classes with different interfaces confuse developers. Aim for consistency in naming and functionality.

16. Combinatorial Explosion

When dealing with multiple flags or options, avoid creating an explosion of combinations. Simplify your design.

17. Conditional Complexity

Complex conditional logic makes code hard to follow. Refactor complex conditions into smaller, more readable expressions.


18. Inappropriate Intimacy

Classes that are too tightly coupled violate encapsulation. Reduce dependencies between classes.

19. Indecent Exposure

Avoid exposing internal details unnecessarily. Limit access to what’s essential.

20. Feature Envy

When one class excessively uses methods or properties of another, consider moving the logic to the appropriate class.

21. Message Chains

Chains of method calls between objects create tight coupling. Simplify chains to improve maintainability.

22. Middle Man

Remove unnecessary intermediary classes that merely delegate calls to other classes.


23. Divergent Change

If a class frequently changes for different reasons, it violates the Single Responsibility Principle. Split it into smaller, focused classes.

24. Shotgun Surgery

When a single change requires modifications across multiple classes, refactor to reduce the impact.

25. Parallel Inheritance Hierarchies

Avoid creating parallel class hierarchies that mirror each other. Simplify your design.

Other Notable Mentions

26. Inconsistent Names

Use consistent naming conventions to improve code readability.

27. Uncommunicative Name

Choose descriptive names for variables, methods, and classes.

28. Type Embedded in Name

Avoid including type information in variable or method names.

29. Magic Numbers

Replace hard-coded numeric values with named constants or enums.

30. Incomplete Library Class

Extend library classes when necessary rather than duplicating their functionality.

31. Inconsistent Formatting

Maintain consistent code formatting throughout your project.

Remember, code smells are hints, not certainties. Use them as a guide to improve your codebase and write cleaner, more maintainable software. Happy coding! 🚀

For more in-depth exploration of code smells, check out the official Detekt documentation.

¹: [Pragmatic Ways – 31 code smells all developers should be familiar with](

Source: Conversation with Bing, 2/15/2024
(1) 31 code smells all developers should be familiar with – Pragmatic Ways.
(2) Identifying and addressing Kotlin code smells – LogRocket Blog.
(3) Uncovering the Scent of Code: Understanding and Eliminating Code Smells ….
(4) 5 most common code smells that you should avoid – Medium.
(5) What are Code Smells? (Examples with Solutions) | Built In.

%d bloggers like this: