tl;dr Use ARC but also know how to do manual memory management.
Personally, I think that manual memory management is very easy. However, personal experience over the last two and a half years has shown me that very few developers can manage memory properly. Since this is the case, I recommend ARC to all developers, especially anyone new to Objective-C.
ARC being "perfect" is entirely subjective. I have never run into any reference counting problems with ARC. However, there are some corner cases to watch out for. For example, all Objective-C objects are put on the heap, except for blocks. Blocks are initially put on the stack, but can be moved to the heap. ARC is built to handle reference counting, not de-stackifying blocks. By handling reference counting, ARC naturally de-stackifies blocks in most cases. There is at least one case it does not handle. This can be viewed as a flaw in ARC, but it is an entirely different problem from reference counting. Though I expect it wouldn't be too hard to get ARC to properly de-stackify blocks too. I would love to have ARC handle this too.
ARC also doesn't handle C memory management. So, if you do anything with AVFoundation, Core Graphics, etc you will need to handle the memory management anyway. I personally don't mind this since memory management is quite easy.
Another issue is that ARC doesn't handle retain loops. However, ARC or not, reference counting always has this problem. Fortunately, Apple has added a weak referencing system to solve the problem.
The key to ARC is you need to learn to trust it, just like you trust a garbage collector (garbage collectors can be flawed too). I personally trust ARC more than any garbage collector. I love doing crazy things with threads. Despite all the use cases I have encountered with threads, I have never had a dangling pointer or memory leak using ARC. Memory management in a multi-threaded environment can be very difficult, and it requires knowledge beyond the basics, especially with autorelease.
Even when using ARC, developers can have memory problems. The problems, however, stem not from ARC but from the developer. Objective-C has some very strong conventions. If a developer doesn't follow the conventions, then ARC can't help them. The most common example of this is knowing when to use copy or strong with an @property. Though, ARC or not, if they mix up copy and strong, they are going to have problems anyway.