There is more to it than that. When we build game systems, one common method of differentiating the work is “things we probably will change” (e.g. things we plan to tune based on feedback) and “things we probably won’t change” (e.g. the way a story character or environment looks). We build the things we expect to change such that it is easy to make those changes. The things that we don’t expect to change are typically not built with changes in mind, because we assume we will lock them in and they’ll be completely finished.
As you might expect, numerical balance values like 10% higher stun duration, 8% less HP, or an extra 5% critical hit rate are often built to be easy to change because we expect to have a lot of things in the game that can change them. A magic blessing spell, a potion that provides a temporary boost, a passive racial ability, or a piece of gear all might provide different modifiers to a character’s health total and we’re probably going to want to tune most of those to make them feel right for their power level and the player experience. Since we expect designers to modify these values a lot, the engineers build the system to make it easy to set and modify those values.
Animations are typically not built to be easy to modify because we don’t need to do it all that often. Most of the time, the character performs the animation and we call it good. We might tweak and modify it leading up to launch, but they are generally locked in once we finalize them. Most games do not need to tune a particular animation beyond being able to scale the animation playback speed to fit within a certain number of frames. Tuning would generally require the animator to make a small change, the designer to play with it and decide if it is good enough, and then make changes if it isn’t good enough. This cycle can take a significant amount of time, and we often have [huge numbers of animations] we need to complete. This kind of iteration often takes too long to do feasibly.
There are exceptions to this, of course. Fighting games, for example, tend to make animation changes regularly because of the way they are built. In addition to damage and health, fighting game strength are all about the character animation start-up, the active duration, and recovery period. A particular move can be buffed by shortening its recovery time or nerfed by increasing a move’s startup duration. Because the designers need to make changes to these animations regularly, the engineers build the animation system to be tunable so that the designer doesn’t need to keep calling on the animators, and the animators can instead focus their time on creating new animation suites for new characters.
Got a burning question you want answered?