All code is tested code.
The Dev Team is a subset of the Agile Team. It consists of the dedicated professionals who can develop and test a Story, Feature, or component. It typically includes software developers and testers, engineers, and other dedicated specialists required to complete a vertical slice of functionality.
For consistency with the Scrum definition, the Dev Team excludes the Product Owner and Scrum Master, who are part of the larger Agile Team.
Developers and testers make up the majority of many Agile teams. Developers write the code for the User stories and conduct research, design, and prototyping. They work collaboratively and may program in a pair with other developers or perhaps with testers.
The developer’s responsibilities include:
- Collaborating with the Product Owner and testers to ensure the right code is being developed; writing the code
- Conducting unit tests and automated acceptance tests
- Checking new code into the shared repository every day
The tester’s responsibilities include:
- Working in parallel with developers to write acceptance test cases (automated wherever possible), while the code is being written
- Interfacing with the Product Owner and developers to confirm that the code and acceptance tests reflect the desired functionality
- Executing acceptance tests and maintaining the test cases in a shared repository
In short: Everybody tests. Everybody codes.
Developers and testers are the core of Agile development. They work in small, cross-functional teams and can quickly create working, tested code that delivers value. They build the systems we all depend on. In traditional development, the developer and tester roles are typically differentiated, often with each reporting into a different management structure. In Agile, the two roles blend. For example, Cohn doesn’t distinguish the roles and instead calls everyone ‘developers’ . Engineers that develop hardware, firmware, and other components are also considered ‘developers’ in the context of SAFe. The line between development and test is purposely blurred. Developers test and testers code.
In addition, in Agile, all code is tested code. To achieve this:
- Developers test. They take pride in ensuring code correctness themselves.
- Testers code. They develop test scripts (code) and go further in actively evaluating the behavior of the code.
- Developers and testers work together to ensure that each story satisfies the Definition of Done (DoD).
- Developers and testers avoid unnecessary formalities, handoffs, and signoffs. Rather, they simply work together until the story is accepted by the Product Owner.
- Developers often assist testers in creating fixtures and automated acceptance tests.
- Testers help developers understand edge cases and develop data sets that more thoroughly test the implementation.
In this way, Agile encourages multi-specialization (‘T-shaped skills’) of team members to foster collaboration and to eliminate handoffs and bottlenecks to flow.
Collocation, Collaboration, and Knowledge Sharing
In Agile, collocation of Agile team members, and the blurring of the traditional roles, optimizes velocity and quality. This is the yin that creates empowered Agile teams. However, the yang is that developers no longer operate collectively from a pool, where one could argue that it was easier to learn, share, and advance collective competencies. To address this, the Agile enterprise must consciously create a culture and environment where best practices and knowledge are shared. This includes new-found Agile skills such as story writing, Continuous Exploration, Continuous Integration, Continuous Deployment, collective code ownership, and automated unit and acceptance testing, which are easily shared across teams. This is often facilitated by Communities of Practice (CoPs).
As implied above, the Dev Team is directly responsible for much of the culture and many of the practices necessary for building the Continuous Delivery Pipeline and implementing DevOps. To this end, their T-shaped skill training also includes developing expertise in developing and managing staging and deployment environments and mastering techniques for independently releasing elements of the larger Solution. They assume additional responsibilities for following the code downstream and into production. This further blends traditional siloed responsibilities such that Agile teams, and even individual developers, can master the ability to Release on Demand.
Design for Testability
Since all code is tested code, developers design and evolve the system to support testability and test automation. In practice, designing for testability and good design are synonymous and imply modularity, low coupling, and high cohesion of layers, components, and classes. This supports the testability of any separate fragment of logic as well as the ability to create higher, system-level, integration tests. In a similar manner, the solution should be designed to make it easy to deploy and release.
Learn More Cohn, Mike. Succeeding with Agile: Software Development Using Scrum. Addison-Wesley, 2009.  Leffingwell, Dean. Agile Software Requirements: Lean Requirements Practices for Teams, Programs, and the Enterprise. Addison-Wesley, 2011.
Last update: 12 October, 2017