Q:

Scala Implicit classes

As per documentation https://users.scala-lang.org/t/sip-13-implicit-classes-scala-documentation/705, use case of implicit class is 
"A new language construct is proposed to simplify the creation of classes which provide extension methods to another type." 
This require creation of new class, respective function and import. 
The same can be achieved by creating Utils classes with static method. I am unable to understand what additional benefit implicit classes are adding here which can't be achieved by Utils classes with static method.

A:

You don't gain any "power" per se, the ability to do something you couldn't do before; however implicit classes offer something static methods in a Utils class don't, clarity.
Say you want to do something, like check if a string contains at least one of several different choices.  You could implement this functionality like this:
object Hello {

    def main(args: Array[String]): Unit = {

        val str =
            """
              |Hello Mary,
              |
              |How's it going? I hope everything is going well with you.
              |
              |Bye!
            """.stripMargin

        println( StrUtils.containsOneOf(str,"Good","well","once","later"))
    }

}

object StrUtils {

    def containsOneOf(stringToCheck: String,strings: String*): Boolean = {
        strings.exists(stringToCheck.contains(_))
    }
}

Which would work, however it also looks a bit clunky.  If we use implicit classes, we could make it look like this functionality was part of the String class all along.
object Hello {

    def main(args: Array[String]): Unit = {

        val str =
            """
              |Hello Mary,
              |
              |How's it going? I hope everything is going well with you.
              |
              |Bye!
            """.stripMargin

        println( str.containsOneOf("Good","well","once","later"))
    }

    implicit class StringUtils(s: String) {
        def containsOneOf(strings: String*): Boolean = {
            strings.exists(s.contains(_))
        }
    }

}

I believe the second example is a lot clearer and once you start building up complicated expressions, this kind of syntax can really help.
Side Note
Since (almost) all programming languages are Turing complete, meaning they can be used to compute anything a Turing machine can, they are in a sense "equally powerful". So how then, given that our languages are equally powerful, should we judge a programming language?
I actually would argue that one of the primary metrics of how good a programming language is, is it's ability to maintain legibility as complexity increases.  Languages that don't have a clear orthogonal base of features which can be combined, tend to end up with a large definition (i.e. lots of edge cases), and end up being more confusing to work in.
This feature's, implicit classes, primary benefit is to helps us to maintain the legibility of our code.

