We are uncovering the bitter truth and
the better way for software development
by improving The Agile Manifesto.
Through this work we have come to these 4 new valuable elements and conclusions.
ResultDrivenDevelopment
Prioritize results over strict adherence to processes or methods. The team is measured on what they accomplish, not how they get there.
Each sprint is defined by clear, measurable targets. The team is free to manage their time and workload however they choose, as long as they meet those targets by the end of the sprint. This fosters trust and autonomy while maintaining focus on delivering value.
If someone chooses to take extra time off during the week, they can still complete their tasks at their own pace, as long as the agreed-upon result is delivered by the deadline.
Foster autonomy and accountability within the team by creating a culture of trust rather than relying on rigid rules and regulations. Instead of micromanaging or enforcing strict policies, team members are trusted to make responsible decisions and manage their own work effectively.
Encourage an environment where team members feel empowered to take initiative and ownership of their work. Trust is built through transparency, open communication, and mutual respect, while excessive rules are minimized to prevent stifling creativity or flexibility.
Instead of enforcing mandatory check-ins or monitoring working hours, the team is trusted to manage their time and communicate any issues proactively. This approach leads to more freedom, as long as the results are achieved.
Mistakes are not failures but valuable learning experiences — This mindset encourages experimentation, innovation, and continuous improvement by allowing the team to make errors without fear of punishment. The focus is on learning from these mistakes to avoid repeating them and finding new ways to improve.
Create a culture where team members are not afraid to take risks or try new approaches, knowing that if they make a mistake, it will be treated as an opportunity to learn and refine their methods. Encourage open discussion of errors in retrospectives, so that lessons are shared across the team.
Instead of penalizing a team member for a failed experiment or a bug in the code, the team could conduct a "post-mortem" analysis to identify what went wrong, how it can be fixed, and what can be done to prevent similar issues in the future. This shifts the focus from blame to problem-solving.
Embrace simplicity in both design and execution, reducing unnecessary complexity wherever possible. The simplest solution is often the best, as it leads to faster delivery, easier maintenance, and fewer errors. This value encourages the team to focus on what is essential and eliminate unnecessary steps or features that don’t contribute to the goal.
Teams should constantly assess their work for opportunities to simplify processes, designs, or workflows. By focusing on simplicity, you ensure that energy is directed toward delivering value rather than managing unnecessary complexity.
When planning features or solving problems, the team should ask, "Is there a simpler way to achieve this?" Simplifying user flows, reducing dependencies, and using lightweight tools are all ways to keep complexity in check.
While we introduce those 4 new elements,
we also keep the 4 core:
1. Individuals and interactions over processes and tools.
2. Working software over comprehensive documentation.
3. Customer collaboration over contract negotiation.
4. Responding to change over following a plan.
That is, while there is value in the items on the right,
we value the items on the left more.