When we look at the agile technical practices, there’s a tendency to believe that these things are new and unproven and nothing could be further from the truth.
Test Driven Development (TDD) has been around since at least the 1950’s. There’s a paper written for a NATO conference in the 1950’s that describes this technique. It doesn’t used the words “test driven development” but does describe the approach.
Pair programming has been in use since the early days of the mainframe. Admittedly, they weren’t using it for the same reasons we are today, but it was in use. Back then the cost of the computer was so much more expensive than the cost of the humans that we paired people up for cost savings.
Mob programming is fundamentally the same approach that we’ve used for decades when we fire-fight production issues. Everyone comes together and works on the same problems at the same time. The only thing that’s different is that we’re now continuing to use the technique after we’ve put out the fire.
I was personally using feature flags in the 1990’s and they weren’t a novel idea at that time. They weren’t as fancy as what we have today but we implemented the same approach.
Trunk based development was the norm before Git came along. Creating multiple branches was possible with earlier version control systems but it wasn’t commonly used. Some might argue that starting to use branches was an improvement but that’s highly debatable in general and I personally disagree.
Continuous integration and continuous delivery have been around at least since the mid-1990’s, although the latter didn’t start to become popular until about 2010.
None of this is new. All of these techniques have been around for decades and have a proven track record.