Question: Basically, I've become accustomed to developing with the mongo that's packed with Meteor, not for anything other than development of course.

I'm beginning to run into features of MongoDB in the newer version that isn't available to me with the MongoDB that's shipped with Meteor.

For example, in Mongo, the $sort within a $push no longer requires $slice:

<http://docs.mongodb.org/manual/reference/operator/update/sort/>

Just curious if this is a limitation or if there's a workaround? I can use a remote DB or local one but the quick dev tools are helpful.

Answer: 
I think you're just misreading the sentence. "Avoid fetching artifact dependencies with either intransitive() or notTransitive()" is intended to mean "If you want to avoid fetching artifact dependencies, the way to do this is with either intransitive() or notTransitive()".
`notTransitive` is just an alias to `intransitive` and is defined like this:

```
def notTransitive = intransitive

```

in [Configuration.scala](https://github.com/sbt/sbt/blob/9c442d3aed53bdc89db1ada9d5b204bf02adb339/ivy/src/main/scala/sbt/Configuration.scala). It's just a matter of preference like `must` and `should` in Specs2, or `size` and `length` in Scala collections.

Usually using default transitive dependency behavior is preferred because it requires less configuration and maintenance - SBT will pull all required dependencies for you. If you decide to upgrade the version of a primary dependency you don't have to manually upgrade all transitive dependencies as well. However, sometimes you either don't need to have a dependency in some scopes, like `Specs2` should be usually available for `test` scope only. In other cases your environment provides all required dependencies and you can make your packaged artifact smaller by not packaging them. Transitive dependency management fits the majority of the use-cases and leads to less errors during runtime (missing implementation, Class not found) and that's why it's preferred. If you know what you are doing there is nothing wrong using `intransitive` option.

Note that by setting `intransitive` on a dependency you are still fetching that dependency if it's in the library dependencies of the project. You are only avoiding fetching its transitive/sub dependencies.

If your SBT subproject builds fine with that dependency and your other SBT project uses that subproject without needing that dependency directly then simply do not include that library dependency into the second project. You don't need to do intransitive conf in that case.

In your case it sounds like dependent projects or environment will provide those transitive dependencies. In that case use `intransitive` if you are technically just compiling against an API like Servlets or some log library.