Having tried Eclipse on and off, and sticking IntelliJ for a while, its a tradeoff between being less useful but more responsive/performant (Eclipse) vs less responsive/performance but more useful (IntelliJ)

One of IntelliJ's biggest selling points has always been its smart auto completion, which is (still) bounds ahead compared to Eclips's. Then there are other things like IntelliJ automatically updating index's when you have local package updated (for example, you have an sbt that is used by other projects, and when you do publish-local, those other projects will automatically update their index's to do deal with the changes in that sbt project). These issues greatly increase when you use libraries that heavily abuse scala's type system, such as Scalaz (scalaz has attempted to alleviate this issue with selective imports, but then that creates a new problem while solving an old one)

Unfortunately, Scala's type system is very complicated and due to this, its a different beast. Getting smart completion/refactoring/analysis has a lot of performance implications, something that isn't an issue with Java (as an example), so there is a real noticable trade off as outlined in the first paragraph. Throw ontop of that implicits, amongst other things, and it becomes apparent its not as fluid as it is in Java. There are some other noticable issues as well, for example IntelliJ incorrectly highlighting correct code as incorrect, it used to be a lot worse, however I am still getting this issue with certain libraries (like when using fold on the scalatra's commands library), however its a safe bet these will be solved as time goes on.

Its important to note, that the reason why IntelliJ is considered such a good IDE is not that its "just an editor", it has a lot of other features within the editor that are incredibly useful, everything from visual diffs/algorithms when using GIT VCS, to polyglot indexing support for languages (you can see this in play, where HTML templates that feature scala blocks, still have completion and indexing on those blocks of Scala code). Its this area where IntellIiJ really shines