Development Culture Change

Verigreen carries a big impact on a development team's culture and productivity in several ways. Once the team adjusts to the quality Evergreen "imposes", it is very hard to lower the new quality bar again and to go to square one.
Although it may take some time to get used to, the benefits cannot be ignored.

No unverified code is integrated to your protected branch.

By unverified we mean any commit which Verigreen was not able to have a "green light" from the CI system. This can happen for various reasons, code failure being just one example. Other reasons could be a merge failure, network issues, etc.
Test failures are also considered as regular CI failure. This one simple fact brings a new level of certainty to the team, since you can rely on it as a developer, team or group leader, project manager, etc.

Change of ownership

Once the developer submits his code changes, until the change is actually merged to the protected branch, it is the developer's responsibility to make sure the change has actually reached its final destination. As Verigreen notifies the committer about the change's status in the system, in case of a failure - the committer must make sure to complete the process to its happy end.
No other person is aware of the change but the committer.
The developer should act upon the failure according to the type of error Verigreen notifies him of by an email and what is seen in Verigreen UI.

Failures are not viral any more

Code changes are being exchanged constantly during the development process. The more frequently it happens, the more impact we see of bad code submissions on the entire team, since developers are pulling each other's changes from some integration or main branch.
For this reason, Verigreen is a great solution for keeping the development team's velocity as it makes sure all changes coming in to your integration/main branch are in a pre-defined good quality level.
In practice, this means people can rely on the code they are pulling now and do not need to deal with errors not related to what they have been doing explicitly. This is a major benefit for all teams, especially (but not limited to) large and distributed ones.

Commit rate submission is increasing

When developers learn that Verigreen is a solution they can trust, they tend to commit their changes more often. This is due to:

1. Developers cannot break the build any more.
2. The quality of the code being submitted is higher since Verigreen is basically an iterative improving process. developers get the feedback quickly from the CI system and fix the issue as soon as they can since the code didn't make it to integration yet (related to ownership).
   The outcome - high pace code submission with better quality.
   The more commits come in, the less content they include, making them more atomic and thus testable, which in turn leads to even higher success rate overall.

No more chasing after code breaks by developers

DevOps/Integration teams have much more time to concentrate on the processes and flows of changes in the system rather than on maintaining the code quality.
This in turn can lead to better productivity and creativity among DevOps teams to better utilize computational resources and shorten release cycle.

Quality control is easy now

Since Verigreen will run any verification job the DevOps team decides upon, reducing or increasing the tests running by the verification job is totally up to them.
Hence, they can control it easily. Once the project progresses, it is natural to believe the demands for better quality will follow. Verigreen can be a big first step towards achieving this goal.