Like code, a build script is executed by the computer. Computers are exceptionally good at following a set of instructions. In fact, (outside of self-modifying code), computers will execute the same sequence of instructions exactly the same way, given the same input. This delivers a level of consistency that, well, only a computer can match.
By contrast, us water filled fleshbags are just downright despicable when it comes to following steps. That pesky analytical brain has a tendency to question everything it comes across. "Oh...I don't need to that", or "Do I really to use this flag? Eh...I'll just ignore it." In addition, we have a tendency to get complacent. Once we've done something a few times, we start believing that we know the instructions, and don't have to look at the instruction sheet.
From "The Pragmatic Programmer":
In addition, we want to ensure consistency and repeatability on the project. Manual procedures leave consistency up to change; repeatability isn't guaranteed, especially if aspects of the procedure are open to interpretation by different people.
In addition, we are HILARIOUSLY sluggish in executing instructions (compared to a computer). On a large project, with hundreds of files and configurations, it would take years to manually execute all the steps in a build process.
I'll give you a real world example. I was working some embedded software, where most of the code was shared across a few different hardware platforms. Each platform had different hardware, but most of the software was the same. But there were little pieces that were specific to each hardware. Ideally, the common pieces would be placed in a library and linked into each version. However, the common pieces couldn't be compiled into a shared library. It had to be compiled with every different configuration.
At first, I manually compiled each configuration. It only took a few seconds to switch between configurations, and wasn't that big of a pain. Towards the end of the project, a critical defect was discovered in the shared portion of code, where a device would essentially take over the communication bus. This was BAD! Really bad. I found the bug in the code, fixed it, and recompiled every version. Except one. During the build process, I got distracted, and forgot one. The binaries got released, the machine was built, and a day later I get a phone call saying the machine stopped responding. I check it out, and discovered a device had locked the bus. "But I fixed that bug!".
I may have fixed it, but it never found its way onto that one board. Why? Because I didn't have an automated build process that built every single version with 1 click.