I'm curious: what about YUI lends itself to scalability?
There really isn't "scalability" in client-side JavaScript. Scalability is usually thought of as the ability to serve many users at once (as opposed to speed which is how fast you serve one person). So, sure Ruby is slower than Python, but it doesn't matter too much since you can have 4 web servers and a load balancer rather than 2 web servers and a load balancer and you're fine.
However, client-side JavaScript isn't serving multiple users at once. It's trying to serve one user as fast as possible.
Maybe someone has a better explanation? It's early and I haven't had my coffee.
EDIT: It seems like YUI might allow you to pull independent pieces by calling YUI.use(some-cool-piece-of-functionality). That could reduce download times, but it could also increase HTTP requests and the associated overhead. That's pretty cool. If 90% of your users aren't going to be using a piece of functionality, it doesn't load that code, but can load it dynamically if needed. While cool, I don't think I'd call this more scalable - this is about speed. And I don't know if it would be faster in a meaningful way since JS can be nicely cached. I shouldn't have said that - in the absence of evidence from testing, I shouldn't make assumptions. Maybe someone else can shed some light on how well this works in the real world.
However, most of the YUI-based stuff I've seen struck me as overly complex and slow and heavyweight, like Ext/JS. If you want to build something that looks and feels like a desktop app those libraries are probably the right choice but I almost always prefer something lighter and cleaner in a web UI.
App A: the UI was mostly composed of HTML glued together with JQuery components, with a custom Model/Controller implementation (similar to Backbone.js) for the data. The view did have a lot of glue, but the data separation ended up a lot cleaner, and was easier for designers to maintain (HTML/CSS).
App B: Was taken over from another team that used ExtJS. App B, had full UI without much effort, but ended up with a lot more cruft and direct view/model dependencies.
Plus the ExtJS documentation is terrible.
I think it's more in terms of if your goal is to make a large JavaScript component suite, what core framework would keep you in clean and functional code through the lifecycle.