   As seen as in the example above, `super` can be used to call the default
   implementation.
 
-  If `@behaviour` has been defined, `defoverridable` can also be called with a
-  module as an argument. All implemented callbacks from the behaviour above the
-  call to `defoverridable` will be marked as overridable.
-
-  ## Example
+  > Note: use `defoverridable` with care. If you need to define multiple modules
+  > with the same behaviour, it may be best to move the default implementation
+  > to the caller, and check if a callback exists via `Code.ensure_loaded?/1` and
+  > `function_exported?/3`.
+  >
+  > For example, in the example above, imagine there is a module that calls the
+  > `test/2` function. This module could be defined as such:
+  >
+  >     defmodule CallsTest do
+  >       def receives_module_and_calls_test(module, x, y) do
+  >         if Code.ensure_loaded?(module) and function_exported?(module, :test, 2) do
+  >           module.test(x, y)
+  >         else
+  >           x + y
+  >         end
+  >       end
+  >     end
+
+  ## Example with behaviour
+
+  You can also pass a behaviour to `defoverridable` and it will mark all of the
+  callbacks in the behaviour as overridable:
+
 
       defmodule Behaviour do
-        @callback foo :: any
+        @callback test(number(), number()) :: number()
       end
 
       defmodule DefaultMod do

          quote do
            @behaviour Behaviour

            def foo do
              "Override me"
            end

            defoverridable Behaviour

        end
      end

      defmodule ChildMod do
        use DefaultMod

        def test(x, y) do
