Working Software over Comprehensive Documentation
Software has limited value if I don't know the extent of what it can do. In some cases, an overview is good (e.g., word processing software), because I'm familiar with the application. In other cases, I need comprehensive documentation. This applies equally well to requirements and to user guides. Defining and learning a new programming language is an excellent example of where comprehensive documentation is key, both up front and after the fact. A compiler that works well supporting some of the language features is less important if I don't understand those features. Also, it’s a waste to have an open source application that has all sorts of features that I can't use because they're not documented.
One of the key issues here is that this item tends to support a view where coding can get underway immediately. This results in less up-front architecture and often in a lot of rework. The push is to get something working fast, rather than to document a good architectural framework on which to build.
Get your architecture right so that you can put working software first. And be critical of the working software. If it's going to require more documentation than users feel it should, perhaps the spec should be simplified. "Why do I have two different panels coming up instead of one?" "Why can't I just click on this to get the information?" "Why is this not consistent with the way other features work?" Working software is great for bringing out these questions. Specifications can be just too wordy to accomplish the same, especially those where 80 percent has been cut-and-paste and the stakeholders just fill in some blanks.
Customer Collaboration over Contract Negotiation
I agree with this. Almost always. It's better for the customer: "You said you wanted this, but if we do this instead, not only do you have that capability—perhaps a bit different than you wanted—but you also get X, Y, and Z, which you didn't ask for." "Wow, that would be great," says the customer. It comes down to this: If you're an expert in building software in your niche field, you understand the customer requirements better than the customer. A few iterations, and the customer begins to appreciate this and wants more.
Still, at times the customer is on a tight budget and timeline or has hard requirements based on external integration specs. So contracts still have their place. But if you told the customer that you could do 80 percent of his features for 50 percent of the cost (30 percent is profit, that's why it's not the 80/20 rule), your customer would likely say, “Yes, let's start there and then we'll look at how we get the rest of the functionality we need, perhaps in the next release.” More than likely, a lot of that functionality either won't be needed or becomes obsolete based on your architecture. For example, I wouldn't dream of integrating CM+ with a database vendor's reporting language just because the customer asked for it or is familiar with it. I'd show them the capabilities in the CM+ architecture that exceed their requirements, and then ask them if they really still need it. Of course, if it's needed to meet a blind requirements checklist, we'd show them how easy the integration is anyway, even though we wouldn't expect them to ever use it. Collaboration is the way to go.
Responding to Change over Following a Plan
Planning is good; it gives you a baseline. The problem is that if you plan out further than you can see, your plans will become heavy millstones. That's what's good about Agile—you plan out in advance a couple of iterations or so (after establishing a good architecture), and then you continue to run on a priority basis, based on what the customer tells you (and often the customer is the market). I'm sure many mobile device companies were working on some nifty pointing devices prior to seeing the iPhone. That changed the game. If they didn't change and respond, they were toast.
At the other end, if you have a lot of features that are highly interactive (i.e., impact one another), then this could complicate your verification cycle. As you reach the 75 percent completion point, you may want to carefully plan your iterations—or at least your release backlog—in such a way as to minimize the chances of destabilization or reduced quality. Yes, your continuous integration is going to help you with quality, especially in light of changing requirements, but at some point, you have to spend time to make sure that your product is 100 percent ready, not just stable enough to keep improving.
Responding to change is following a plan—it's just a more fluid plan that focuses on priorities more than dates and on minimizing acceptance risk more than content completion risk. Your customer collaboration will help you deal with any specific risk items adequately.
So, those are my views of the Agile Manifesto. Maybe you agree 100 percent, but more likely you don't. I welcome your comments and will respond to them in a timely fashion.