I found reflection easier to understand by looking at the Given typeclass rather than the Refies class (Given is simpler, but I think occasionally less well behaved). Then we can implement the following:

implicit :: (a -> b) -> (Given a => b)
implicit f = f given
explicit :: (Given a => b) -> a -> b
explicit a b = give b a

Aside from the performance issues edward mentions there are some interfaces that you simply can't implement with Reader that you can with reflection. For instance, try to implement Eq for a Reader-based modulo number. The best you could do is liftA2 (==), but that would return a -> Bool, while you need Bool. But with reflection you can move the fact that you're returning a function out of the type signature into the instance context, so you have:

newtype Mod a = Mod a
instance (Given a, Integral a) => Eq (Mod a) where
    Mod a == Mod b = normalize a == normalize b
      where normalize a = a `mod` given

You don't even really need a Given constraint for Eq; if you move the Given constraint into the various Num methods you can make sure that you can't construct an un-normalized modulo number, in which case we already know it's normalized when we try to equate two Mod values.

With the actual Reifies class we can also guarantee that we can't equate a modulo 8 number with a modulo 16 number; the extra phantom type parameter makes numbers in different modulos have different types. We can also provide an Ord instance similarly, which means we can construct Maps which use modulo-numbers as keys, which we can't do with Reader (I think this is only safe with Reifies, not Given).

A while back I was experimenting with aping imperative syntax with lenses to write code that's polymorphic over whether or not you're in a monad, so you could do things like:

while ((!x) < 10) $ do
    y =: foo (!x) + (!y)
    x =: (!x) + 1

Where anything to the right of (=:), or in the while-loops condition were given read-only access to the state monad's state. Without reflection the best I would have managed would be something like:

while (fmap (<10) (view x)) $ do
    y =: ((+) <$> fmap foo (view x) <*> view y)
    x =: ((+) <$> view x <*> pure 1)

Even adding instance (Num a) => Num (Reader r a) would only help for code that's polymorphic over Num. In the general case you have to constantly liftA2/pure/fmappure functions to work over the Reader monad, whereas the reflection-based interface does so automatically.

http://lpaste.net/139394 has the implementation if anyone's curious.