Developing Quality Software Competency
Business Problem
We have technical software delivery bottlenecks and frequent post-release defects with high maintenance costs.
Business Outcomes
- Reduced post-release defects and maintenance costs.
- Faster resolution of critical software vulnerabilities, including a reduction in rework and support.
- Increased trust in AI system reliability and accuracy.
- Enhanced ability to adapt to evolving technical demands.
Why is the Developing Quality Software Competency important?
Agile Software development requires modern practices that reliably and predictably create quality software systems and products. These practices originated with eXtreme Programming (XP) but have significantly evolved over the past two decades.
Maintaining quality engineering practices in software development is even more crucial in the current AI age. Flaws in software can lead to AI system failures or vulnerabilities, potentially causing significant harm or financial loss. Additionally, as AI systems become more integrated into critical infrastructure and decision-making processes, the consequences of software failures escalate. Emerging practices such as MLOps, ModelOps, and AIOps are concerns of Agile software development. MLOps manages the deployment and maintenance of machine learning models. ModelOps ensures AI model scalability and accuracy over time. AIOps uses AI to automate and optimize IT operations, integrating various tools for proactive monitoring and issue resolution.
The Developing Quality Software Competency is focused on practices specific to software and software quality. Software may well be the richest and best-defined area for applying Built-in Quality. This was driven by necessity, as software is exceedingly complex and intangible. You can’t touch it or see it, so traditional approaches to inspecting, measuring, and testing are inadequate. If quality isn’t built in endemically, then it’s unlikely to exist at all.
Which roles would benefit from mastering this competency?
Software Engineers, Quality Engineers, System and Solution Architects, Product Owners, Scrum Masters, Release Train Engineers, team-level technical coaches, and SPCs.
Learning about the Developing Quality Software Competency
The following resources are suitable for beginning your learning journey in the Developing Quality Software competency:
Agile Software Engineering Video Blog Series
In this series, Ken Pugh, a leading Agile Software thought leader and author, provides a comprehensive video overview of Agile software practices, each aligning well with SAFe’s Agile Software Engineering course.
Artificial Intelligence (AI)
Artificial Intelligence (AI) is a term used to describe a wide range of smart machines capable of performing tasks that typically require human intelligence. When paired with quality software development, AI can unleash innovation in Agile Teams.
Behavior-Driven Development (BDD)
Behavior-driven development (BDD) is a test-first, Agile Testing practice that provides Built-In Quality by defining (and potentially automating) tests before or as part of specifying system behavior. BDD is a collaborative process that creates a shared understanding of requirements between the business and the Agile Teams.
Test-Driven Development
Test-driven development (TDD) is a philosophy and practice that involves building and executing tests before implementing the code or a system component. By validating them against a series of agreed-to tests, TDD—an Agile Testing practice—improves system outcomes by ensuring the system implementation meets its requirements.
Nonfunctional Requirements
Nonfunctional Requirements (NFRs) are system qualities that guide the design of the solution and often serve as constraints across the relevant backlogs.
Refactoring
With continuous refactoring, the useful life of an investment in software assets can be extended as long as possible. Users can continue to experience a flow of value for years to come. Refactors enable an emergent design, ensuring the system continues to meet future business needs
Spikes
Defined initially in Extreme Programming (XP), spikes represent activities such as exploration, architecture, infrastructure, research, design, and prototyping. Their purpose is to gain the knowledge necessary to reduce the risk of a technical approach, better understand a requirement, or increase the reliability of a story estimate.
Applying the Developing Quality Software Competency
Here are some tips for beginning to apply quality software practices:
- Learn and adapt – Be open to learning new practices and tools. Adapt your approach based on what works best for your team.
- Start with the basics – Focus on fundamental practices like Test-Driven Development (TDD). These help catch issues early and involve all team members in practicing together.
- Set Clear goals – Define what quality means for your Agile Team. Establish clear acceptance criteria for features and stories that include new techniques that are proving to work for you.
- Automate testing – Automate tests to ensure code quality. Don’t be shy about augmenting your work with AI tools that speed up your work and enable you to have more time for innovation and system stability.
- Encourage collaboration – Foster a culture of teamwork. Encourage your team members to share knowledge and pair work.
- Gather feedback – Regularly seek feedback from your teammates, users, and stakeholders. This helps identify areas for improvement.
- Measure progress – Track quality metrics to see how well your practices are working. Use this data to make informed adjustments.
Agile Software Engineering Certification Course
In the Agile Software Engineering course, you’ll learn how modern practices like XP, behavior-driven development (BDD), and test-driven development (TDD) enable continuous value flow and built-in quality. This interactive, three-day course also provides guidance and tools to work effectively in remote environments with distributed teams.
Mastering the Developing Quality Software Competency
When quality software development practices are applied across Agile Teams with mastery, the following should begin to be prevalent:
- Defined processes – Teams have clear definitions of done and acceptance criteria for their work, including applying chosen practices. This ensures everyone understands what is expected.
- Quality focus – Teams consistently deliver high-quality software. They use practices like Test-Driven Development and Spikes to catch issues early.
- Frequent feedback – Teams regularly seek feedback from customers. This helps them understand what works and what needs improvement.
- Continuous improvement – Teams track their performance metrics. They use this data to fuel retrospectives and set new goals for improvement. Refactoring and eliminating technical debt are standard parts of allocated capacity within teams.
- Collaboration – Team members work closely together, sharing knowledge and skills. This creates a stronger product and a resilient workforce to emerging technologies.
- Adaptability – Teams quickly respond to changing requirements and feedback. Their technical practices assist these shifts. As technology evolves and organizational policies permit, more engineers use AI to adapt to new trends and tools, keeping their skills relevant.
Nimbus Networks’ Quality Culture
Nimbus Networks faced a new challenge: ensuring true quality in their rapidly evolving software, data, cloud, and AI infrastructure. The “Creating Great Agile Teams” initiative had empowered their teams, but frequent post-release defects and escalating maintenance costs highlighted a need for more.
Enter the “Developing Quality Software Competency.” Maria, a seasoned architect, championed this next phase. She saw that while teams were faster, the quality wasn’t consistently built in. “It’s like building a beautiful house quickly, but forgetting to check the foundation,” she explained to her team.
The first step was to embed Test-Driven Development (TDD) into every software team’s workflow. This meant writing tests before the code, a radical shift for some. The initial resistance was met with clear goals and dedicated coaching from Quality Engineers. Soon, developers started seeing fewer bugs slip through, and their confidence grew.
Next, the data teams focused on Behavior-Driven Development (BDD). They began writing clear, business-focused scenarios for their data pipelines and AI models. This helped bridge the gap between what the business needed and what the data engineers built. For example, before an AI model was deployed to recommend cloud services, the BDD approach ensured everyone agreed on “Given a customer with X history, when they browse Y services, then the AI should recommend Z with 90% accuracy.” This clarity drastically improved the reliability of their AI system’s output.
For the cloud infrastructure teams, applying the competency meant rigorous attention to Nonfunctional Requirements (NFRs). Performance, security, and scalability became non-negotiable aspects defined and tested early in the development cycle. They started using automated testing tools, augmented by AI, to constantly monitor the health and stability of their cloud environments. This proactive approach helped them identify and resolve vulnerabilities faster than ever before.
Collaboration was paramount across all teams. Software engineers, data scientists, and cloud specialists began pair programming and cross-training. Spikes, defined as exploration and research activities, were used to tackle complex technical challenges, reducing risk before major development efforts. Refactoring became a continuous practice, regularly cleaning up code and infrastructure to prevent technical debt from accumulating.
Regular feedback loops were established, not just from users but also internally. Team retrospectives evolved to analyze quality metrics deeply, leading to continuous improvement. If a new defect cropped up, the teams not only fixed it; they investigated the root cause and adjusted their practices to prevent recurrence.
Within months, Nimbus Networks saw a dramatic reduction in post-release defects and maintenance costs. Critical software vulnerabilities were resolved with unprecedented speed. Most importantly, trust in their AI systems soared. Customers experienced fewer glitches, and the AI models consistently delivered accurate and reliable results. The journey continued, proving that resetting their agility practices was just a first step; building quality into everything they did was a valuable additional focus.
Continuing Your Journey through the Team and Technical Agility Discipline
Continuously Delivering Value
DevOps and Continuous Delivery are important parts of accelerating product development flow. Each Agile Release Train (ART) builds and manages or shares a pipeline with the practices, tools, and resources to deliver value independently.
Cross-Team Coordination
This competency discusses managing and prioritizing work across teams, improving collaboration, and speeding the flow of value delivery.
Last Update: 13 February 2026