Code grows and it grows quickly and ugly. Being able to recognize ugly patterns of code as soon as possible, is essential. This is what code smells are. Fancy named structures of code that we usually end up with and that might indicate a problem.
Code that is big and hard to work with.
A method that has too many lines of code(more than 10), making it hard to work with.
A Class that has too many lines of code, fields, methods and too many responsibilities, making it hard to work with.
A group of variables which are passed around together.
More than three parameters on a method.
Use of primitive types(string, numbers) instead of objects.
Misuse in Object Oriented Programming.
Complex switch statements or a sequence of if statements.
Sub-classes use only some of the methods and data inheirted from parent classes, keeping unneeded methods unused or redefined to throw undefined exceptions.
Classes performing same functions but have different method names.
Temporary properties that get their values under very specific circumstances, otherwise remains empty.
Things that make code harder to change.
Forces changes in many unrelated class methods when changes are made to a class.
Forces you to make many small changes to many different classes.
Forces you to make changes into parallel subclasses.
Things that are pointless and not needed.
Code filled with explanatory comments.
A class that does nothing or too little and does not deserve to be separated.
Code that was written for a future requirement but never unused.
A class that only contains fileds and simple methods to access them.
Same code in differrent places.
Unused code.
Things that generate coupling between classes.
A Class works with data of another class more than its own.
A class uses the internals of another class.
Consecutive method calls where each method returns another object and a method on that object gets called.
A Class that exits just to delegate work to other class.