Computation expressions provide the syntax, but not the abstraction power, of monads. Would be nice to have full monads, but still, CE are *extremely* useful to communicate clearly in code. For example, I am now doing some asynchronous socket processing including parsing input messages and sending output messages. After musing about it for a while, I figured that what I need is the Async monad enhanced to carry a state (I want this to propagate unparsed leftover input).

module StateAsync =
    type StateAsync<'S,'T> =
        private { Run: 'S -> Async<'T * 'S> }

    let LiftAsync a =
        let g s =
            async {
                let! x = a
                return (x, s)
            }
        { Run = g }

    let GetState =
        let g s = async.Return(s, s)
        { Run = g }

    let SetState s =
        let g _ = async.Return((), s)
        { Run = g }

    let Run { Run = f } s = f s

    let Return x =
        let g s = async.Return(x, s)
        { Run = g }

    let Bind f x =
        let g s = async.Bind(x.Run s, fun (v, s) -> (f v).Run s)
        { Run = g }

    type StateAsyncBuilder = Do with
        member this.Return x = Return x
        member this.ReturnFrom(x: StateAsync<_,_>) = x
        member this.Bind(x, f) = Bind f x
        member this.Bind(x, f) = Bind f (LiftAsync x)

With this in place, I can define for example a parser that collects all input until a delimiter (for example, to read the HTTP request head before CR LF CR LF):

let readUntil (delimiter: string) (read: Async<string>) =
    let rec loop acc (input: string) =
        StateAsync.Do {
            match input.IndexOf(delimiter) with
            | -1 ->
                let! x = read
                return! loop (input :: acc) x
            | k ->
                let result =
                    input.Substring(k) :: acc
                    |> List.rev
                    |> String.concat ""
                let leftover = input.Substring(k + delimiter.Length)
                do! StateAsync.SetState leftover
                return result
        }
    StateAsync.Do {
        let! state = StateAsync.GetState
        do! StateAsync.SetState ""
        return! loop [] state
    }

Naturally, there are different ways to write this but the CE syntax helps making the purpose clear, and also helps reasoning about the code.

mapM :: Monad m => (a -> m b) -> [a] -> m [b]

module type MONAD =
sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a -> ('a -> 'b t) -> 'b t
end

module MonadUtils(M : MONAD) =
struct
  (* ... *)
end

Typically you don't need to create your own as the built-in ones or those that are part of a framework (such as WebSharper) are all that you would need.
Occasionally, you do have a need. I created one to manage COM object references from F#:

[link:fwaris.wordpress.com] .

I believe it important to *understand* how to create computational expressions because that will give you deeper insights into functional programming (consider it a rite of passage for F#).

When starting with computational expression look at the boilerplate implementation in the F# spec (section 6.3.10 ):

[link:research.microsoft.com]

I've been using F# for at least 2 years and haven't yet come across a need for creating my own computation expression. That could be due to a) the domain in which I work and b) the fact that you can invariably express the same concept other ways (in that sense, CEs are merely a syntactic convenience). I think they're less important in an impure functional language--obviously a language like Haskell couldn't do much without monads.