> Hmm maybe, but if we're not monkey patching it could be a legitimate case that someone else defines those methods...

I'm not too concerned with that.  (Consider that we've been defining `describe` for years and have never received any reports about problems).  You could use something less likely to be defined by someone else, though...such as `shared_examples_for`.  Or you could get the method object for one of those and check the `owner` or `source_location` to see if it's actually RSpec that defined it.

Actually, thinking about this issue some more, I've realized that there's another oddity here that could result from the fact that `Configuration#initialize` calls `expose_globally = true`.  Consider code like this:

``` ruby
RSpec.configure do |c|
  c.expose_globally = false
end

RSpec::Core::Configuration.new
```

In this case, the top level DSL methods will be exposed globally even though the user has configured it not to.  Further more, `RSpec.configuration.exposed_globally?` will return `false` (which is a lie).  That seems like a nasty bug to me.  How is this for an alternate solution?

* Have the methods be exposed globally at load time (e.g. when one of the files related to this is loaded) rather than in `Configuration#initialize`.  That way, it happens once, and the instantiation of new configuration instances doesn't affect it.
* Make the `expose_globally!` and `remove_globally!` methods idempotent.  Then `expose_globally=` can be defined more simply as:

``` ruby
def expose_globally=(value)
  if value
    Core::DSL.expose_globally!
    Core::SharedExampleGroup::TopLevelDSL.expose_globally!
  else
    Core::DSL.remove_globally!
    Core::SharedExampleGroup::TopLevelDSL.remove_globally!
  end
end
```

Then if you want to define a `expose_globally?` predicate (which is more idiomatic than the `expose_globally` method you have now), it can simply be:

``` ruby
def expose_globally?
  Module.method_defined?(:describe)
end
```

In this case I think it's safe to not worry about if someone else has defined `describe` on `Module`; we're not basing any logic on `expose_globally?` but instead just providing it as a query method for end users to be able see which way it's set, so it's far less of a concern if users have done things to confuse it.

FWIW, this is how rspec-expectations and rspec-mocks manage their syntax config and it's always worked pretty well.