gotcha. so for the first part, my thought was that the `shorthands` in this PR were actually how we "conforming with the spec". as in it makes sense for having each one be built of smaller pieces like `commonjs` and `concat` but then that the spec comes into play by making these shorthands ease to access. does that make sense?

oh! what if we changed this so that the shorthand methods just pushed the plugins onto the current build stack instead of actually ending the batch as well. so then using them would be like this:

```js
builder
  .scripts()
  .styles()
  .build(function(err, build){
    ...
  });
```

which means that using them is super easy that way (don't even have to reach into things exposed on the static like `Builder.scripts` or `Builder.concat` which is kinda ugly feeling anyways) and so that adding more coffeescripts or something would be simple as:

```js
builder
  .scripts()
  .use(coffee())
  .build(fn);
```

but then the `scripts` itself can still be composed of smaller plugins like `concat('scripts')`. and we wouldn't expose those plugins on the builder at all, because they'd be in separate repos that people can just require in instead.

that doesn't solve any of the require stuff haha. but for the require things, i think we're going to need a different solution anyways, because even just adding `.coffee` files to get compiled would also need to be part of the same system right?

can we just have a thing where instead of getting `cat`d together they just get pushed onto an array somewhere that the builder knows about?