All code is tested code.



Dev Team

The Dev Team (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 who are required to complete a vertical slice of functionality.

For consistency with Scrum, 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 pair program with another developer or a with a tester. The developer’s responsibilities include collaborating with the Product Owner and testers to make sure the right code is being developed; writing the code, unit tests, and automated acceptance tests; and checking new code into the shared repository every day.

Testers work in parallel with developers to write acceptance test cases (also automated wherever possible) while the code is being written; interface with the Product Owner and developers to confirm that the code and acceptance tests reflect the desired functionality; execute acceptance tests; and maintain the test cases in a shared repository.

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. While in traditional development, the developer and tester roles are typically differentiated, often with each role reporting into a different management structure, the two roles blend in Agile. For example, Cohn ([1]) doesn’t distinguish the roles and 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 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
  • Developers and testers avoid unnecessary formalities, hand-offs, and sign-offs. 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.

Colocation, Collaboration and Knowledge Sharing

In Agile, colocation of Agile Team members, and the blurring of the traditional roles optimizes velocity and quality. This is the “yin” that creates empowered Agile teams. The “yang”, however, 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, including the new found Agile skills such as story writing, Continuous Exploration, Continuous Integration, Continuous Deployment, collective code ownership, automated unit- and acceptance testing—and many more—are easily shared across teams. This is often facilitated by Communities of Practice.

Continuous Delivery

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 silo-ed 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

[1] Cohn, Mike. Succeeding with Agile: Software Development Using Scrum.  2009.

[2] Leffingwell, Dean. Agile Software Requirements: Lean Requirements Practices for Teams, Programs, and the Enterprise, Addison-Wesley, 2011.


Last update: 21 May, 2017