It's nearly Christmas! The perfect time to get busy buying presents, decorate our homes and to look back at our achievements over the past year.
Agile teams should also take a moment to reflect and celebrate their own achievements and remind ourselves of its original values.
I've been reading the BCS Agile Foundations book and have found it refreshing to take a step back and reflect on what the roots of agile development are and how it's used within the teams I work with.
Agile teams often find themselves starting out on the right foot but quickly focus on trying to churn out as much work as possible, as quickly as they can to meet customer demand and forgetting about everything else. But this isn't what being agile is all about.
Agile is a people first, value first model with a key focus on quality. Here's how it's often portrayed
- Immediate return on investment
- Agile doesn't require much planning
- Blame the agile team if they don't finish everything
- Quickly put code together with little thought or design
Here's a brief look at the 4 agile values and their 12 principles to take us back to the foundations of agile development.
1. Individuals and Interactions Over Processes and Tools
Focus on individuals communication to create a strong team that is focused, over following strict rules and using tools that cause a distraction because that's 'just how it's done here'
2. Working Software Over Comprehensive Documentation
Value and quality are top priority in anything agile. It's up to the customer to define what working software (UAT) means and the Product Owner to drive it's value. Documentation still needs to be done but not at the sacrifice of working software.
3. Customer Collaboration Over Contract Negotiation
Work with customers as much as possible, ask for feedback and keep them involved. This is the best way to guarantee we are building the right thing at the right time. We need a form of contract but it's important to understand that even though budget and quality are fixed, features are likely to change.
4. Responding to Change Over Following a Plan
The team commits the work in a sprint, and gets it done. The team decided what their definition of done is at the start. This means every sprint we are able to change direction of what we're building. We follow are a plan but we welcome changes in that plan.
1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
2. Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
4. Business people and developers must work together daily throughout the project.
5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
7. Working software is the primary measure of progress.
8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
9. Continuous attention to technical excellence and good design enhances agility.
10. Simplicity--the art of maximizing the amount of work not done--is essential.
11. The best architectures, requirements, and designs emerge from self-organizing teams.
12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behaviour accordingly.
It's easier said than done to achieve all of these so should be a pursuit for all of us, but if we use these as the guide they were intended, we’re on the way to creating better products and better teams.