Seven Strategies for Successful Agile Development

February 12, 2013 · 0 comments

Agile is not a silver bullet but it does have the potential of improving software development when done correctly. Unfortunately, teams newly adopting agile practices often don’t know how to get the most out of applying agile practices until it is too late. Here are seven strategies for getting more from agile software development.

1. Build in batches
Perhaps the most important benefit of agility is what I call the Charlamainge Approach or Divide and Conquer. It’s worked for civilizations for thousands of years so why not for software development? Simply put, take a big problem and break it down into smaller, more manageable problems. Smaller problems are easier to solve and along the way we just might discover valuable pieces of the solution we didn’t think of ahead of time.

2. Have a product owner
The product owner represents the customer or user of the software being built. Their job is to identify the next most important features to build and to groom the backlog so the stories that will be worked on next are ready to start. The product owner does not have to be a technical role; having someone who has a clear idea of the priorities and goals of the software to be built can be invaluable for keeping development on track.

3. Integrate continuously
Building software is a risky business and fraught with challenges. Code often ends up intertwined in ways that are not obvious until it is integrated into the rest of the system. The agile approach is to integrate code all the time, several times a day, into a central build server that can run a suite of automated tests that proves new code “plays nice” with the rest of the system. This helps us catch bugs faster and reduce risks.

4. Define acceptance criteria
Knowing when we are done building a feature can be a challenge for developers. It is not that we try to gold-plate, but if we don’t know how a feature will be used then we may tend to make it more robust than it needs to be. Having a well-defined set of acceptance criteria helps us know when we are finished with a feature and when we can move on to the next one.

5. Master design skills
Iterative development often means we are going back to code we wrote earlier and enhancing it. Without following specific technical practices to make code changeable, we can end up painting ourselves into a corner. Agile design skills are critical to making agile work in practice, yet most developers do not know techniques for writing changeable code and end up wasting a lot of time and energy.

6. Pay down on technical debt
Maintenance and upkeep is an important part of managing any asset and software is no exception. Most code is not written to be maintainable and sometimes we forsake code quality to get things out the door. When this happens, we may find it more cost effective to clean up critical pieces of code rather than let them fester. Just like with credit card debt, we want to pay off our technical debt as soon as we can to avoid those steep interest fees.

7. Understand the principle behind the practices
Many of the practices of agile and Scrum are deceptively simple but without understanding the reasons why they are there we may not apply them most efficiently. Understanding the principles that underlie these practices can help us to better apply them.

Building software is very different than building tangible goods and the same principles and practices do not apply. Agile software development intends to be lightweight without the checks and balances built in to waterfall development. But this doesn’t mean we can just hack out code; successful agile software development is highly disciplined and requires a deep understanding of of why and how great software is built.

Leave a Comment

Previous post:

Next post: