The number one indicator of badly coupled modules in my opinion is bilateral dependencies. For example, Module1 one calls some function in Module2 and Module2 calls some function in Module1.
Most interfaces should be unidirectional. If the module that was called needs to pass some information to the calling module that is not returned as part of the call then it should use some sort of message passing or event triggering mechanism such as a message queue. Ideally, the handle to message passing interface should be passed in during some initialization or registration process. This completely abstracts the interface in such a way that the module does not actually care who the event is for...hence it is decoupled.
Another indication is when one module is constantly calling some other module for some specific data set. This should make you question who should actually own the data set. Why is it that this module in question always needs to see data that belongs to some other module?
A third tool so to speak is to ask yourself, "Can I pull this module out and replace it without requiring changes to other modules.
This is by no means a exhaustive list, but they are the top three things I ask myself when designing software.