Well, I think mostly about the tools I usually use: JavaScript, Haskell (GHC is really absurdly awesome), Emacs (which has really good support for
certain languages including JavaScript and Haskell but emphatically not Java), TeX, GNU/Linux, Git and probably a bunch of other tools and libraries that don't spring to mind immediately.
I have used Visual Studio (mostly for C++ but a tiny bit of C# for WPF stuff), but not too much. I've found myself significantly more productive with Emacs, but I've also now used Emacs quite a bit more. I also used a full version of Intellij in my summer job, but was thoroughly unimpressed.
Now, I'll grant that the tools I've listed tend to have harsh learning curves. However, I posit that they are exceptionally effective in experienced hands. I think this is not a drawback: learning a tool is a constant expense where being more efficient is a benefit proportional to how much you use that tool. I would rather have tools that are harder to learn but more efficient than the opposite. Now, it is true that a tool that is easy to learn does not have to be less efficient and a tool that's harder to learn does not have to be more efficient, but I have found the two to be correlated in practice.
While the user-facing FOSS projects may be less polished in general, I have found that this does not hold nearly as much for developer tools. The main problem with letting developers design UIs is that they assume that everybody thinks like them; this isn't an entirely unfair assumption when writing tools for fellow developers! As I have mentioned, while FOSS developer tool UIs may be harder to learn, I have found them superior overall. Emacs is a perfect example--it does not follow any conventions of other common software (it pre-dates all that other software, after all) but within itself it is by far the most consistent UI I have ever encountered. In fact, I think Emacs is a great picture of brilliant UX; the sole problem is that it lives in its own universe (and isn't as slick or shiny as some newer options).
And of course, with the right lisp incantation, you can do magic.
Finally, it is true that the majority of FOSS projects become stagnant. Then again, this is doubtless true of the majority of non-FOSS projects as well. Back in my Windows days, I would frequently encounter "shareware" that had fallen into disrepair. The main difference is that an abandoned FOSS project can easily be patched or even brought back to life (JS-2 mode is a perfect example of this); abandoned proprietary software is basically dead.
Now, clearly, proprietary programs like Visual Studio supported by large companies will not die. But that is true of big open source projects as well: most of the ones I listed aren't disappearing any time soon. So stagnation is really constant across all software; the difference is that FOSS software is much more difficult to kill completely.
Hopefully my aimless ramblings have cleared my views on the subject.