This is the follow-up to this post. It's a bit more nitpicky.
For 2D games, the Mecanim animation controllers are not great. They tend to be just big webs where every state can go to every other state, which gets unmanageable when every animation has 4 directional variants. You can work around this though by playing states manually. In the cases where you need long chains of animations, the transition system is quite useful.
It's weird how you setup animation events - not in that the editor design is bad, but that before you create an event you also have to have the method written out that will receive the event. Fine if you're just one guy. But if your artist is working independently from your programmer, you either have to collaborate closely, your artist needs to learn rudimentary coding, or your programmer needs to edit animations. For some cases this is unavoidable - like when the events are complex - but most of the time you just want to fire off a named event and have code listen for that, and the artist should be able to handle the animation editing on his own.
There's no good way to listen for when an animation ends. There really ought to be a clean way to do this, but there really isn't.
Unity's Sprite Packer does some things well and does some things very poorly.
One cool thing that it does is create a mesh out of the sprite instead of using a naive rectangle. This saves on fill-rate, requiring the pixel shader to run less often. It does increase raw triangle count and makes the vertex processor work a bit more, but that usually isn't an issue.
One bad thing that it does is pack poorly! TexturePacker outperforms it pretty solidly. At first I attributed this to the complexities introduced by trying to fit together complicated meshes in a sheet rather than rectangles, but even if you turn off the Unity mesh generation, its packing is still worse.
I mentioned this in the first post, but there's more:
Once you start downloading plugins from the Asset Store, your workspace gets really cluttered really fast. There's absolutely no standardization on directory hierarchies or asset placement. Some plugins like to throw things in your root folder. Some plugins nest things 5 folders deep. Sometimes plugins use the same directories for the same ideas, sometimes they don't. Sometimes a plugin will introduce direct conflicts with other plugins - especially hazardous on Android builds.
It rapidly escalates into a Huge Mess.
It boggles my mind that Unity couldn't provide one serialization option that works on iOS with the binary stripping level at its maximum setting. Both the XML & Binary serialization choke. You have no choice but to roll your own. A lot of people recommend Google Protocol Buffers, but that has some weirdness associated that I didn't want to drudge into.
Some clever usage of ISerializable and IDeserializationCallback can make binary serialization available if you're willing to roll up your sleeves.
Curiosities & Miscellaneous
Screen.width and Screen.height return the wrong values in the editor. How crazy is that? They're consistently half the actual pixel dimensions of the game view.