The short answer

Require every agent pull request to arrive with proof: what was expected, the steps that ran, a replay, expected versus actual for any failure, and a classified verdict, all from a verifier that didn't write the code. TestSprite produces exactly that on every pull request, so your reviewers spend their time on judgment instead of reconstruction.

Proof on every PR

The full regression suite runs against the pull request's build, and the result posts as a comment.

Checkable in a minute

Each failure carries a replay, the failing step, and expected versus actual.

Proof that can't be gamed

What a test expects only changes when a person approves it, so the evidence stays honest.

Why review is moving from diffs to evidence

Claude Code, Codex and Cursor now write most of the code at many companies, and they produce it faster than anyone can read it. A diff also answers a narrower question than reviewers need: it shows what changed, not whether sign-up still works, the invoice total is still right, or a member can suddenly see an admin page. Those answers live in the running app.

In her talk "All Code Is Slop (Except Mine)" at the AI Engineer Code Summit, Lauren Tan said her team's code review had "really shrunk into looking at verification artifacts." Her team merged about 11,000 pull requests in a month with roughly a 0.5% revert rate. Her "trust pyramid" constrains agents first through the code itself (architecture, lint rules, types), then through runtime and formal verification, and only lightly through written rules. The artifacts are videos, screenshots and, for some flows, formal proofs.

Reviewers still read code where design is at stake. What changes is the default: judge the evidence first, and read the diff where the risk is.

The proof checklist: seven things to require

Strong evidence answers seven questions. Here is what weak and strong answers look like:

EvidenceWeakStrong
What was expected"Tested login""After signing in with a one-time code, the user lands on the dashboard showing their workspace name," from the ticket or PRD
The stepsA summary in the descriptionThe exact steps that ran, in order
A replayOne screenshot of the finished pageA replay of the whole run, so you can jump to any step
Expected vs actual"Test failed""Expected the total to include tax; the total excludes it," at the failing step
A classified verdictRed or greenReal bug, test problem or environment issue, with the reason
ScopeThe new tests onlyThe full regression suite, with passed, failed and blocked counts
ProvenanceUnknownWhich commit, which environment, which run, and what produced it

The first and last rows are the most often skipped and the most valuable. The expectation turns a run into a check against intent; provenance ties the evidence to the exact commit you are about to merge.

Independent proof beats self-reported proof

Several tools now attach a video to agent pull requests, and seeing a feature run is useful context. Proof becomes decisive when it comes from a verifier independent of the author, for two reasons.

Coverage. An agent naturally records the path it built and expects to work. An independent suite runs every approved flow, including the checkout the new settings page quietly affected.

Enforcement. A video has to be watched and judged by hand on every pull request. A suite produces a status check, so the merge itself can depend on the result.

So the strongest proof comes from a verifier with its own approved record of what the product should do, expectations that change only when a person approves, and a result your merge rules can require. The guide on why the author shouldn't grade its own work covers that separation in depth.

A six-step routine for reviewing an agent pull request

  1. Check the gate. Did the full suite run against this commit? Is it green, or is every failure classified?

  2. Read the intent. Open the ticket or PRD entry. If the pull request adds behaviour, is there a new approved test stating it?

  3. Scan for changed expectations. Did any test's expected outcome change? Who approved it, and does the ticket support it?

  4. Open each failure. Jump the replay to the failing step, read expected versus actual, and confirm the classification.

  5. Spot-read the risky code: authentication, payments, permissions, deletion, data migrations and architectural changes.

  6. Decide. Merge, or send it back with a link to the failure; the coding agent can take the failing step and expected versus actual as its next input.

Where code review still earns its time

Proof covers behaviour; design is still a human call. Keep reading code for changes to architecture or module boundaries, new dependencies, security-sensitive paths, and data migrations a test environment can't fully reproduce. In Lauren Tan's pyramid much of this is enforced at the base, through architecture, lint rules and types, which stop whole classes of mistakes before review. Review proof for what the change does; review code for how it is built.

Get the proof without building the pipeline

Lauren Tan built her verification layer in-house: a feature map of the product, runtime verification skills driving Chrome DevTools, custom CLIs, and fuzzing on release. It took about six months. TestSprite delivers that layer ready to use.

  • Tests from intent. Describe what your product should do in plain words, or point TestSprite at your PRDs and tickets. It drafts a test plan in which every test states its expectation in plain language, and you approve it.

  • Proof on every pull request. Through the GitHub App or GitHub Actions, the full suite runs against the pull request's build, frontend and backend, and the result posts as a comment.

  • Evidence for every failure. A real bug, test problem or environment issue, with a replay, the failing step, and expected versus actual.

  • Honest by design. Steps update as the interface changes; what a test expects only changes with a person's approval.

  • A gate, not just a report. Turn on Block PR until tests pass and the proof decides the merge; the merge gate guide covers the setup.

For teams with audit requirements, every run is attributable to the account that triggered it, TestSprite maintains SOC 2 compliance, and enterprise plans add SSO with SAML, SCIM, audit logs, single-tenant deployment and data residency.

Frequently asked questions

Does "review proof, not code" mean nobody reads the code?

No. Reviewers lead with the evidence and read code where design, security or data migrations are at stake. The diff becomes a targeted read instead of the whole review.

Is a video from the coding agent enough?

It is good context. For the merge decision, pair it with an independent suite: it covers flows the agent didn't think to record, and its result can be a required status check.

What if the agent says a failure is just flaky?

Check the classification and the replay. Test problems and environment issues are labelled as such, with evidence; a real bug shows expected versus actual at the failing step. The reviewer decides, with the facts in front of them.

How should an intended behaviour change show up?

As an explicit expectation change, approved by the feature owner with the ticket as the reason, visible to the reviewer alongside the run that proves the new behaviour.

Does this only work on GitHub?

The GitHub App and GitHub Actions post results to the pull request directly. On other CI systems, the open-source CLI runs the suite and returns an exit code your pipeline can gate on.

Try TestSprite

Make every agent pull request bring its own proof.

Your reviewers can't read every diff a coding agent writes, but they can judge evidence quickly. TestSprite runs your regression suite on every pull request and posts a replay, the failing step, expected versus actual and a classified verdict, from tests the coding agent can't rewrite. Start on the free tier with one real flow.