Note: I am focusing only on the design impact of TDD. To better understand the overall impact, see this series of posts by Jay Bazuzi.
My first experience with TDD was back in 2002 or so, and it was in C++, so there weren't any mocking libraries available. That meant that I had to use hand-written mocking classes.
When hand-mocking, you need to create separate classes, write each of the methods that you need, etc. If the scenario is complex, you may have to write several classes that coordinate with each other to accomplish the mock. It's more than a little pain at times, and creating a new class always seems like a bit of an interrupt in my train of thought.
That is as it should be. One of my foundational principles of running development teams is that pain which, in this context, means, "tedious things I have to do instead of writing new code" is a great incentive. That which is tedious is an automatic target for reduction and elimination. So, you have developers fix their own bugs because it will cause them pain to do so.
(This is, of course, not a panacea; there are plenty of organizations where this will not result in better quality because the incentive towards writing bugs is so strong, but I digress)
Then mocking libraries showed up the scene. No need to write new classes, just write some mocking code and you're done. That reduced the pain and reduced the design pressure that 'the test is hard to write" was exerting, which reduces the improvement.
Then a few mocking libraries showed up that let you mock statics, which allows you to test things that were totally untestable before, and that further reduced the design pressure. You can do some pretty ugly things with those libraries
Refactoring gets harder
Many of the mocking libraries have another problem they use a string-based approach for defining their mocks. This means that they are not refactoring-friendly; after you refactor your code, you find out that your tests won't even run; you have to go and hand-modify them so that they now match your new refactoring. This makes refactoring more painful, and makes it more likely that you will just skip the refactoring
As you have probably gathered, I am not a fan of mocking libraries. They make it too easy to do things that I think you shouldn't, and they short circuit the feedback that you would otherwise be feeling. Embrace the pain of writing your own mocks, and use that to motivate you towards better solutions. I'll be talking more about better solutions in future posts.
There is one situation where mocking libraries are great; if I need to bring an existing codebase under test so that I won't break it as I work on it. In that case, I need their power, and I will plan to get rid of them in the longer term.