It is very unpopular view.
I have never been a fan of unit testing and instead I prefer end to end functional tests -- where you write tests that verify your application still behaves exactly as expected but does not care how it is implemented.
This usually requires much less code, does not deter refactoring and also focuses on the one thing that is really important for the client.
Since the outside interface of the application is less likely to change compared to the implementation, the tests tend to be more stable and require less maintenance over life of the application.
Unit tests were supposed to help refactoring (by making it easier to ensure the code still works after change). The sad reality is that I can never trust unit tests. I still need to research the code around the function I am modifying to be sure I am not breaking anything.
Also my personal style is to do shit ton of refactoring. This means I usually start with something that only vaguely resembles the end result. I spend a lot of time moving stuff around until I get rid of everything that I don't like.
This absolutely precludes writing unit tests up front. But also, after I have spend so much time polishing the code, writing unit tests for it is absolutely the last thing I want to do. There is absolutely no possibility that people will put effort into writing tests well if they did good job writing the actual implementation.
Yet another reason why unit tests are broken is that there is no mechanism, no feedback loop to ensure quality of tests.
When you write application code, if it is broken you will have feedback in the form of defects and outages or various other problems.
One reason that documentation is usually broken is because there typically does not exist mechanism that would ensure that documents stay in sync with design and implementation.
The same problem with unit tests. The only strong signal you get is when the test does not work. But there is no good signal to fix real important problems like missing tests for important part of the contract.