For a system to be a system, there has to be some coupling between the parts.
High coupling is not necessarily "wrong". Sometimes things are coupled, and there's no point pretending otherwise. In that case trying to make it look decoupled makes the code more verbose and less clear.
For example, there is inherrent coupling between data and its presentation. Obviously they should be separate layers, but many programmers advocate 3-tier. But some think that's too tightly coupled so they advocate 4-tier and so on it goes, hence the name "n-tier architecture" to cover them all. But in the end you can't get away from the inherent coupling, putting in more layers doesn't change it, all you end up doing is making the code more abstract and verbose and harder to understand and maintain.
See horizontal slicing with n-tier architectures at large scales.
Consider the blog post Why coupling is always bad / Cohesion vs. coupling (2008) by Vidar Hokstad. He says:
Surely increasing dependencies on implementation details of other components isn't a good thing? The objections I've seen typically doesn't actually usually imply that coupling is good, though, but that coupling isn't always bad because it's necessary to achieve high cohesion. Some evils are necessary, but that doesn't make them good. I will not try to argue that increasing coupling isn't sometimes worth it - see below. Coupling is always bad because it prevents the replacement or changes of components independently of the whole. It's hard seeing a defense against this, and indeed hard to argue for it because it appears so self evident. What are some of the consequences of high coupling?
He says: I can't think of a single benefit of high coupling in and of itself.
Well actually the benefits of high coupling can be:
For example, directly accessing members of a struct is simpler than going through getters/setters on an abstract interface.
Similarly see the GeeksforKeeks article Coupling in Java which states:
In general, Tight Coupling is bad in but most of the time, because it reduces flexibility and re-usability of code, it makes changes much more difficult, it impedes test ability etc. loose coupling is a better choice because A loosely coupled will help you when your application need to change or grow. If you design with loosely coupled architecture, only a few parts of the application should be affected when requirements change.