A mathematical formula to make agile work

I was speaking to some experienced Agilistas about whether “Agile” had a good or bad reputation at the moment.

We spoke about agile maturity models, agile certification, real agile versus pretend agile and even whether there was a right way to do agile. We did not come to any agreement about whether certification and maturity models were good or bad but we did agree there was no one formula for success in agile.

This seemed logical at first but then I thought there really should be one formula we can apply. That way we can simply measure people on whether they are using it and correct their approach for them.

So after minutes of detailed research and experimentation I came up with the following formula.

In case it needs a little explanation – Success in agile is a function of:

• The sum of the ability(Wi) and care factor (accountability or ACi) of each person in the team divided by their individual cowboy like tendencies (CBi) where n = the number of people in the team;
• Multiplied by the ability of the team to self organise (A-so) and the effectiveness of the governance of the organisation (G-c)
• Where the ability to self organise is equal to the delegated authority (DA) of the team and the clarity of the boundaries the team can speculate and innovate within (CB).
• DA is equal to 1 minus the misalignment of accountability (what you are blamed/rewarded for) and authority (what you can change or make happen/fail). Note that this is regardless of whether you have accountability for what you don’t have the authority to make happen or you have the authority to do things that you are not accountable for (ie someone else gets blamed for).
• All divided by the factors that make it harder to be agile – the number of people in the team ( n) plus the real constraints holding the team back (RC) plus the organisational antibodies that attack new ideas with false constraints and other weapons (AB);
• All multiplied by the team learning factor (LF) which is equal to the sum of the team’s willingness to learn (Wl) and their ability to learn (Al) less the ”Safe to fail fudge factor” (Sf). Sf in turn means the extent to which the organisation says it is safe to fail in general but not this particular time.

Applying this simple formula should therefore lead to successful agile.

Taking it a step further, we can use the formula to produce the following pattern that we can imbed in our code to automate the process in a sub-routine. This is written in King 2.0 but can be translated into Java or Ruby on Rails:

	If:
		AND(team turns up and really tries;management gives some support);
	Then:
		Return(Success); Call Continue;
	Else:
		Return(Error); Exit;
	Endif;

Turns out to be easier than many people think – certainly easier than developing standardised maturity models and robust certification of good agile.

Of course there will be a delay before we get the code written and tested, so in the meantime I guess we can use the following workaround ….. the team should try to do the best they can, measure what happens and try to improve. But since others have also tried before and measured what happens the team should try to learn what others did and add that to their kitbag so they can try to apply the same approaches themselves.