Design methodologies do not imply a waterfall-based development methodology. A Service Design Methodology can compliment an Agile approach.
The Agile vs. Waterfall debate is often framed as an argument of extremes. People experienced in a variety of development methodologies understand that a tuned process is more nuanced than the this vs. that blog entries described.
The characteristics of a good development process include:
Upfront planning is essential but the trick is to know what needs to be determined, how much detail needs to be known, and making sure that the plans evolve in response to experience gained from successive iterations. Mistakes will be made. It's better to make them fast and adjust than to follow out a predetermined plan through to absolute failure.
Refactoring is an accepted practice in agile development. This is how we incrementally improve based on what we know vs. what we are assuming. The risk is that a software project hits a wall where a major refactoring is required. Code is branched. It takes months to complete. Then it doesn't merge back in. This happens when there is no designated stable point in the system design on which everything can depend and evolve around.
We see this when a system depends on a framework to such an extent that replacing that framework requires more work than be be tolerated in iterative cycles. An example is the hot and cold relationships people have with ORMs and DAO/DTO frameworks.
Some architects oppose agile-based methodologies. These tend to be the architects who are more design oriented who distrust an iterative and/or distributed development environment without solid blueprints to follow. Again, the issue is how much needs to be determined on the blueprint and what can be deferred to iterative cycles where experience and re-prioritzations dominate.
Large-scale projects are making more use of teams working in parallel to each other. One enterprise architect noted, "five teams iteratively developing five products in parallel." This argues for some blueprint from which to work.
Service Design Methodologies such as the OSIDs provide some relief to this dilemma.
However, service contract changes can have significant impact on a project. It is important not to jiggle service contracts on an incremental basis and rely on service contracts as the stable point in a system.
Service contracts need to evolve much more slowly which means they need to incorporate much more than is called for and there's a reasonable level of confidence that they will hold up. OSIDs are an out-of-the-box suite of service contracts where many interoperability issues have already been incorporated into its design. OSIDs provide a solid blueprint for how to approach a development project and do so incrementally.
If OSIDs define more functionality and interoperability than most of us need, how do we not spend resources developing unimportant stuff? OSIDs are broken down into small clusters of compliance (OsidSessions) that can be broken off and implemented one piece at a time. It usually requires a guiding hand to not wander into areas not valued by your project.
How can OSIDs possibly define everything I need? It doesn't. OSIDs define the integration issues around many service domains along with some common data in these service domains. All of the "objects" are extensible in such a way that methods and data may be added outside its core specification. There's plenty of room to add your own stuff and have interoperability through the core specifications. Like development methodologies, the concept of interoperability is a bit more nuanced than yes/no.