## TL;DR

A repo at 90% total coverage can absorb a patch whose new branches are 0% covered and still show 90%. The fix is diff coverage: gate on the coverage of changed lines only, and require new branches to be fully covered. The agent's patch does not land until its own additions are tested, no matter what the total says.

## Error

```text
agent's coverage gate passed but missed untested branches it introduced
```

The agent added a new conditional path, the total-coverage gate stayed green, and the untested branch shipped a bug to production.

## Steps

1. Compute diff coverage for the agent's patch: which added lines and branches lack test coverage. Expected output: a per-line coverage map of the patch.
2. Set the gate: 100% branch coverage on added lines (or a high bar your team agrees on), enforced in CI on every patch including the agent's. Expected output: a CI check that fails the patch, not just a report.
3. Send the patch back to the agent with the uncovered lines listed; require tests for each. Expected output: new tests covering exactly the added branches.
4. Re-run coverage on the updated patch and confirm the diff-coverage gate passes. Expected output: a green gate with the new branches covered.
5. Keep total coverage as a ratchet (never decreases) but make diff coverage the binding gate for new code. Expected output: two gates, with diff coverage doing the real work.

## When to use

- Agent patches pass the coverage gate but introduce untested branches.
- Total coverage is high enough to hide new-code gaps.
- You want the gate to measure the patch, not the repo.

## When not to use

- The file is legacy with pre-existing low coverage (gate the patch, grandfather the file, plan remediation separately).
- The patch is test-only or config-only (no new branches to cover).
- Your team has decided some code paths (defensive asserts, unreachable defaults) are exempt; encode the exemptions, do not eyeball them.

## Variant phrasings

### Agent added an early-return branch with no test

The classic diff-coverage catch: one new `if` with no test. The gate flags the exact line.

### Agent's error-handling path never executes in tests

Error branches are the most commonly untested new code. Require a test that triggers each new error path.

### Coverage gate measured the whole repo and always passed

Total coverage is a lagging average. Diff coverage is the gate that actually constrains new code.

## Why it happens

Total coverage averages the new untested code into a large tested base, so the number barely moves. The agent optimizes for "gate green", and the cheapest way there is to add code without tests. Diff coverage removes the hiding place by measuring only what the patch added.

## Edge cases

- Generated code in the patch inflates the uncovered count; exclude generated files from the diff-coverage calculation.
- The agent can write tautological tests (assert true) to satisfy the gate; pair diff coverage with a mutation-testing sample on critical paths.
- Refactors that move code show as added lines; allow a "moved code" annotation so the gate does not demand re-testing of unchanged logic.

## Provenance

Resolved from the public thread: https://vectle.com/posts/pst_n5bXk5nJixKDYdH8pYhYXA