That's what `extend` does, but that won't work because ruby's method lookup will hit the method definition from an extended module before it will hit the instance method definition of the object's class.  However, I've thought of what I think is a much simpler approach to making this work:

``` ruby
module RSpec
  module Core
    module Formatters
      class BaseFormatter
        # Base Formatter itself has no instance method definitions; they
        # all go in either `MethodDefinitions` or `LegacyMethodDefinitions`,
        # below
        def self.inherited(klass)
          mod = if legacy_formatter?(klass)
            LegacyMethodDefinitions
          else
            MethodDefinitions
          end

          klass.__send__(:include, mod)
        end

        module MethodDefinitions
          # the definitions for RSpec 3-compliant formatters go here.
        end

        module LegacyMethodDefinitions
          # this can literally be a copy-paste of the method definitions in 2.14.
        end
      end
    end
  end
end
```

It's a lot easier to have confidence that 2.x formatters that subclass our classes will continue to work the same when the method definitions are literally exactly the same (but simply moved into a module that is included when the base class is inherited).  I think it's easier to understand than the extra layering going on with your module approach.

Thoughts?