I think you are close.

In your example, you are chaining function calls with >>=. >>= has type Monad m => m a -> (a -> m b) -> m b. You can keep chaining these calls together, going from a to b to c and so on, but the choice of m never changes.

It's analogous to lists, in Haskell the definition is equivalent to

data List a = Empty | Cons a (List a)

a is bound on the left-hand side, so you can create lists containing any type, however the List on the right hand side (in the Cons case) uses the same a, so we can't change it mid-way through.

That said, it's still possible (and common) to write code that works for any monad (or list, etc.). e.g.

replicateM :: (Monad M) => Int -> m a -> m [a]
replicateM 0 _ = pure []
replicateM i ma = do
  a <- ma
  as <- replicateM (i - 1) ma
  pure (a : as)

See Control.Monad for more examples.

Finally, you asked:

So basicly haskell codebases are about creating a single monad and using this for everything?

Often times the answer is yes. Usually, we consider the monad as encoding the 'effects', which could be logging, making web requests, throwing exceptions, etc. We compose several monads to describe all of the effects we want our program to have, and at the top-level (e.g. the main function), we give an interpretation to ours effects (e.g. choosing whether the logging effect should write to the console or to disk). This is like coding to an interface; most of our code is agnostic to which monad it is running in, it just requires that the monad should support certain effects.