I am in the business of providing outsourced software development. When we design the requirements of a new software development a Requirement Manager will go through the entire project with the client and find out what specifically the client needs.
Often times the client is not necessarily aware of all the requirements it has when the project starts. There are general ideas, but sometimes the general concept has not been completely thought out.
A good Requirement Manager can be extremely beneficial in a situation like this. He/She will think along with the client and sketch out in technical terms what functionality the developers have to code.
The requirements then form the basis of the development model.
In a traditional development model (Gantt Charts and Milestones) at certain predetermined intervals the clients get a chance to review an interim product built and, once approved, the next step of the product will be developed.
The Agile development is different in so far that the client stays much more involved in the development. There is a constant back and forth (usually daily) with questions raised by the developers (typically through the Project Manager) and being answered by the client.
For a more in depth explanation of what an Agile project development looks like see here
Testing of certain functionalities happens much more frequently and often times unrelated development steps are being conducted at the same time.
The whole idea of an Agile project development (versus Gantt and Milestones) is to make the client more involved, thus enabling him to constantly improve upon the final product. Nonsensical development is supposed to be recognized earlier on..thereby reducing 'errand" development time.
One can argue which approach is better. I certainly feel Agile is the way to go.
One inherent side effect which develops out of the Agile Project Management approach are changing requirements. What typically happens is that the more the client gets involved in the development process and gets to play around with the product...the more the client gets a feel for what the final solution should truly look like under real life conditions.
Consequently a client will update the requirements. Features get added and / or amended.
Needless to say...the adding of additional features makes the development more expensive. Every time an additional feature is added more hours have to be paid for.
Therefore the argument has been made that Agile is "more expensive".
I wholeheartedly disagree with that opinion and, as a matter of fact, believe that an Agile approach will make the development cheaper.
That might seem counter intuitive at first..but here is why.
It is a simple fact that the Minimum Viable Product built ( MVP , the first development) is always just the first step to a more final product. As soon as the MVP is out and people start using it there is feedback coming in, suggesting updates and improvements.
Using an Agile approach ensures that the MVP is a much better solution than the MVP built using a simple Gantt based approach.
Precisely because the client has been more involved in the development and was able to add and/or update features while development was still going on less actual software development (= less developer time) had to be done.
It is obviously much cheaper to add a feature at an early stage (or amend functionality) when there are less interconnections to be worried about. By completing these changes earlier in the project a significant time saving can be accomplished versus changes to a released Minimum Viable Product built.
The Agile Development approach delivers a reduction in development time because the product release will be much closer a a more "More Final Product".
Using a Gantt development approach the costs to bring a Minimum Viable Product to a a more Final Stage Product are often times significant.
Anyone who has been in the Software Development Business long enough can tell stories where entire functionality modules were just missed...and had to be created after the fact (the MVP built) at great expense.
Using Agile a better MVP gets created, one which much more resembles a Final Product. Because the MVP built using the Agile approach is better the overall development costs are reduced.