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

WhenCheckOutput
On every merge to mainFull regression suite on the merged commitPass or fail with logs
When a release candidate is cutDiff since last release: functions, deps, config, migrationsChange list for the release owner
SameMutation proof on changed, high-risk functionsProven and unproven list, test-only patch for gaps
SameReview of unproven functionsFix now, or accept and record
After releaseStore the evidence with the release tagA 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.”
Adnan Ashraf, Director of Product Management, Cisco

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.