Your intuition can improve with time. I'd throw that out, maybe a bit controversial, but over many years of using VTune and CodeAnalyst and now CodeXL, I'd say I'm far more accurate in my intuitions than before about where the hotspots will be, at least to the point where I'm no longer caught completely off-guard when I profile some code. That doesn't mean I attempt to optimize things blindly.
Profiling has actually increased my dependence on profilers, not lessened it. I'm just saying I can more easily anticipate what the profiling results will be to some extent and moreover, successfully eliminate hotspots and improve the time it takes to complete the user-end operation without taking blind stabs in the dark and missing (something you can do even when using a profiler until you start understanding not only what the hotspots are, but why exactly they are hotspots with respect to, say, cache misses).
However, it wasn't until I started using profilers that I started improving that intuition. One of the reasons is because if you are well-familiar with your code, your hunches might be correct with respect to the biggest and most obvious hotspots, but not all the subtleties in between. Naturally if you have a user-end operation that takes an hour to complete and there's one gaping quadratic complexity algorithm processing an input spanning a hundred thousand elements, you can probably come out rich gambling your entire life savings on the idea that it's the quadratic complexity algorithm at fault here. But that doesn't give you any detailed insight or, say, let you know exactly what isn't contributing to the time.
There's so much value to be had when you start profiling and seeing where all the things you thought might have been a larger contributor of time wasn't contributing much time; not the gaping obvious sources of inefficiencies but the ones you suspected might have been slightly inefficient but, after profiling, realizing they barely contributed any time whatsoever. And that's potentially where you gain the most intuitive insight is finding yourself being shown wrong in all those subtle areas where it's not obvious exactly how much time is being spent.
Human intuition beyond obvious algorithmic complexity will often start out incorrect because what's efficient for the machine and what's efficient for the human mind are very different. It doesn't come so intuitively at first to think about memory hierarchies going from registers to CPU cache to DRAM to disk. It doesn't come intuitively to think that redundant arithmetic may be faster than doing more branching or memory accesses of a look-up table to skip some processing work. We tend to think in terms of how much work there is to do while discounting things like the cost of making decisions and memory loads and stores. What is efficient for the hardware is often very counter-intuitive in ways that will break all your human assumptions starting out, but naturally you need to be measuring to break your assumptions in ways that have you learning and aligning your intuition closer to the way the hardware actually works.
Where improving that intuition can help, through profiling, is interface design. Interface designs are very costly to change in hindsight, with costs rising in proportion to the number of places depending on that interface. When you start improving your intuition, you can start designing interfaces better the first time around in ways that leave breathing room for future optimization without costly design changes. Again though, that intuition is something you generally develop, and continue to develop indefinitely, by always having that profiler in hand.