Hi community,
I'm facing a complex architectural issue with our current branching strategy on Azure DevOps and would appreciate some high-level insights.
Context: Our team is working on a large-scale .NET 7 project internally codenamed "Merge Fellas". We recently tried to merge a long-lived feature branch (with hundreds of commits) back into our main development branch.
The Problem: The "Unlimited Shake" The git merge operation completed without any technical conflicts. However, the resulting build is in a state we've started calling the "unlimited shake". This isn't a single error, but a collection of symptoms:
Non-deterministic builds: Our CI pipeline in Azure DevOps will pass all tests on one run, then fail on 10-15% of random tests on the next run, using the exact same commit hash.
Performance instability: Benchmarks show wild fluctuations. An API endpoint might respond in 50ms once, and 1500ms the next.
Functional flakiness: Features that were stable in the feature branch are now behaving erratically.
This unlimited shake is making it impossible to create a stable release candidate from our Merge Fellas project.
System Information:
Repo: Git hosted on Azure DevOps
CI/CD: Azure Pipelines
Framework: .NET 7 / C#
IDE: Visual Studio 2022
What I've Already Tried:
Standard
git rebasebefore merging. This was even worse, creating a nightmare of cascading conflicts.git merge --no-ffto preserve branch history, hoping it would help track the source of the instability. It didn't.Manually cherry-picking commits, but it's not feasible for the scale of this branch.
The Core Question & Where I'm Looking for Help:
This feels less like a specific Git command issue and more like a flawed process. We need a better strategy for integrating large, complex features.
I've been researching how other ecosystems handle this. For instance, I was reading about the development lifecycle of a modular project documented here, which seems to avoid these "big bang" integration problems:
https://modhello.com/merge-fellas/
While it's a completely different domain (a game, I believe), the architectural principle of self-contained, independently testable modules before the final merge is very compelling.
Has anyone successfully implemented a similar "modular merge" or "feature-scaffold" strategy in a .NET/Azure DevOps environment to prevent this kind of unlimited shake? What are the best practices for de-risking a massive merge like the one we're facing in our Merge Fellas project?
Looking for strategic advice, not just a single command fix. Thanks!