We're working on a project that was inherited from previous engineers with no crossover. The first thing we did was write an end-to-end integration test suite f

We're working on a project that was inherited from previous engineers with no crossover. The first thing we did was write an end-to-end integration test suite for all the features we could find, which has grown more comprehensive over time. We still have old code we know is working alongside newer code written in a completely different style. We've been able to make major changes in tools and conventions over time while keeping progress steady. While we'd love to clean up all the code and have a single set of the latest conventions the decision is always refactor it now or maybe punt and we'll get to just delete it later, we usually go for the latter. I think the biggest benefit has been that the tests are isolated from the implementation details so we can always be sure everything is still working without having to refactor the tests themselves. There is still a learning curve for new people because they don't know which of the multiple conventions in the code are the presently-agreed-upon ones, and that is where we could probably use some better documentation, but I think the end-to-end tests really saved us from the idea that some knowledge is lost and we might need to start over.