Guide
Post-merge, pre-release checks: verifying the code you are about to ship
Updated November 17, 2026
Most quality tooling is aimed at the pull request. Review bots comment on diffs, CI runs on each branch, and branch protection decides what may merge. That is the right place for many checks. But the code you release is not any single pull request. It is everything that merged since the last release, combined, on your main or release branch. This guide covers what is worth checking in that window, after merge and before release, and how to do it without slowing every merge.
Why the window between merge and release matters
Each pull request is checked against the main branch as it was when the PR was opened or last updated. By release time, things have moved:
- Changes interact. Two PRs each pass review. One adds a caller to a function; the other changes that function's edge-case behavior. Neither PR's tests cover the new combination.
- Volume is up. With coding agents, a team that merged a few dozen changes a week may now merge hundreds. mabl wrote in November 2026 that its own engineering went from about 235 changes a month to around 300 a week. Per-PR attention drops as volume rises.
- Tests drift. Tests written for one PR may be weakened, skipped or regenerated in a later one, and nobody looks at the combined effect.
- Pre-merge checks are tuned for speed. PR gates are deliberately small and fast so they do not block developers. mabl, for example, keeps a 17-test smoke gate on PRs and runs its full 294-test regression suite only after merge.
So the window between merge and release is where you can afford slower, deeper checks on the combined code, and where those checks see what will actually ship.
What to check after merge, before release
1. The full regression suite on the merged build
Run everything you skip on pull requests: the full unit and integration suite, end-to-end flows, and performance and migration checks. Do it on the exact commit you intend to release. Several vendors support this pattern directly, including mabl's post-merge regression runs and QA.tech's "Test after merge" automation, which triggers a test plan when a pull request is merged.
2. What changed since the last release
Produce a list of the functions and modules that changed between the last release tag and the release candidate. This is the scope for the deeper checks below, and it keeps them affordable. It is also the list a release owner should skim.
3. Whether the changed, risky code is protected
For the changed functions that matter (money, permissions, data deletion, retries, scheduled jobs, anything with many callers), ask the question CI cannot answer: would a test fail if this function broke? A green suite says the tests passed. It does not say they check anything.
The way to answer it is mutation proof. Break each risky function on purpose in an isolated copy, rerun the tests that call it, and confirm at least one fails at its own assertion. Where none do, you have a precise finding: this behavior ships unprotected. That can be fixed with one focused test before release, or accepted knowingly.
4. Dependency, config and migration changes
Lockfile updates, feature flag defaults, environment config and database migrations often merge with light review. List them for the release and confirm each has either a test or a rollback plan.
5. Evidence you can keep
Record what was checked on which commit: which suites ran, which functions were proven, which were not, and who accepted the gaps. When something goes wrong in production, this record shortens the investigation. When nothing does, it is what you show an auditor or a customer asking how you validate AI-written code.
Gate or evidence?
A post-merge check does not have to block anything. There are two reasonable models:
- A release gate blocks the release until checks pass. mabl, for example, describes a release tagging gate alongside its PR gates. Gates work when the checks are fast, reliable and trusted. A flaky gate gets bypassed.
- A release evidence step produces a report and, where needed, a fix, and a person decides. This fits deeper checks like mutation proof, where a finding is a judgment call: some unprotected functions need a test today, others are acceptable risk.
Many teams start with evidence, learn which findings matter, then turn the reliable parts into a gate.
A simple post-merge, pre-release routine
| When | Check | Output |
|---|---|---|
| On every merge to main | Full regression suite on the merged commit | Pass or fail with logs |
| When a release candidate is cut | Diff since last release: functions, deps, config, migrations | Change list for the release owner |
| Same | Mutation proof on changed, high-risk functions | Proven and unproven list, test-only patch for gaps |
| Same | Review of unproven functions | Fix now, or accept and record |
| After release | Store the evidence with the release tag | A record of what was proven |
Where OrangePro fits
OrangePro is built for step 3 of this routine and for the evidence it produces. The free, MIT-licensed local engine maps every public function in your repository, links each one to the tests that actually call it, and ranks unproven functions by likelihood of change, what they can break and how hard a break would be to notice. Run it on the merged code, scoped with --base to what changed since a base branch, such as your last release branch.
For each risky function, the proof step breaks the function in an isolated copy and reruns your unchanged test. The receipt records that the test passed on the original code and failed at its own assertion on the broken copy, or that it did not. Where no test catches the break, OrangePro can draft a focused test using your own model key and export it as a test-only patch, so your source files are never touched and the new tests live in your repository. Evidence stays in .orangepro/ with the commit it checked.
OrangePro is not a PR or release gate. It does not review pull requests or decide whether you ship. Local scans do not upload your source and there is no telemetry. Mapping, ranking and proof need no model key.
“A green build only tells you the tests you have passed. OrangePro showed us which changed functions no test would catch if they broke, and gave us tests we could keep in our own repo.”
Frequently asked questions
A check that runs on the main or release branch after a pull request merges, rather than on the pull request itself. It sees the combined code from all merged changes.
Pre-merge checks need to be fast so they do not block developers, and they only see one change at a time. Deeper checks that need the combined code, or that take longer, fit better after merge and before release.
Not necessarily. A gate blocks the release. A post-merge check can instead produce evidence and fixes for a person to act on. Many teams start with evidence and gate only the checks they fully trust.
Look at what each changed function touches (money, data, permissions, deletion), how many callers it has, whether it runs unattended, and whether any test is proven to catch a break in it. OrangePro ranks functions on similar inputs with fixed weights and shows the inputs behind each row.
Add one focused test that fails when the function is broken, prove it, and merge it before release. If that is not possible in time, record the gap and who accepted it.
Try it on your code
See which functions in your next release are protected by a test that would fail if they broke. Run the MIT-licensed engine locally on your merged branch. Local runs do not upload your source.
npx -y @orangepro/mcp-server@latest start .Built for after merge, before release. It is not a pull request or release gate. Local scans do not upload source.