Product proof · PAY-231

Peertic found a duplicate charge risk in a GitHub pull request.

In a recorded run on GitHub PR #2, Peertic read the linked payment retry requirement and flagged a duplicate charge risk at src/payments.mjs:14–15. It posted an inline comment and failed the GitHub check. A regression test reproduced the defect. After the fix and documented AI assistant triage of an initially missed test, a full review posted an approval and successful check. The repository was created for this demonstration.

Recorded Peertic GitHub App run · 18 October 2026

What happened in this run?

1high severity inline PR finding
2 → 4passing tests before and after
4GitHub review rounds recorded
Successfinal GitHub check, after AI assistant triage
  1. RequirementGitHub issue #1, written before review, said two concurrent requests with the same idempotency key must cause one gateway charge and receive the same charge ID.
  2. First changeThe service checked for an existing charge, then called the gateway, then stored the result. Its tests covered later retries and invalid amounts, but not concurrent requests.
  3. FindingPeertic identified the gap on lines 14–15, connected it to criterion 1, posted an inline comment, requested changes, and completed a failing GitHub check.
  4. VerificationA new concurrent retry test failed on the first version: expected one gateway call, observed two. The fix stored an in-flight promise before awaiting it and cleared the key if the gateway failed. All four tests then passed.
  5. Follow-upThe first GitHub recheck found no new issue but incorrectly kept the old thread open because it did not see the test file. An AI assistant checked the test in the PR and resolved that sample thread. A later full review reported zero findings, approved the PR, and completed a successful check. The portal classified the initial finding as resolved.

Watch the GitHub review walkthrough

This 34-second visual summary follows the saved product sessions and GitHub review records from issue to final check. The same sequence is described in text below.

The first GitHub review found the concurrency issue; later rounds show the fix, AI assistant triage of the follow-up, and a successful final check. Read the transcript. A separate local CLI walkthrough shows the same commits reviewed with a file-supplied criterion.

How did the requirement reach the review?

The GitHub App connection read issue #1 from the private sample repository. The first PR session saved its exact four acceptance criteria in the review context before Peertic evaluated two changed files. The project used gpt-6.1-sol, high severity as the blocking threshold, GitHub reviews, and check runs. The linked issue was also supplied as a Markdown background file for a separate local CLI run of the same commits.

Before

const previous = chargesByKey.get(idempotencyKey);
if (previous) return previous;

const charge = await gateway.charge(request);
chargesByKey.set(idempotencyKey, charge);

After

const inFlight = Promise.resolve(gateway.charge(request));
chargesByKey.set(idempotencyKey, inFlight);
try { return await inFlight; }
catch (error) {
  chargesByKey.delete(idempotencyKey);
  throw error;
}

The code panels shorten the call arguments for readability. The exact GitHub PR diffs, saved input context, and runnable source are in the evidence bundle.

What was configured, and where did review data go?

This demo used a running Peertic automation project for the private sample repository, a GitHub App connection able to read the issue and PR and publish reviews and checks, and the codex / gpt-6.1-sol model configuration. The project policy requested changes for high severity findings and enabled GitHub checks. Issue #1 was linked in the PR description.

Peertic saved the review sessions in its local workspace and posted the finding, review decision, and check back to GitHub. The release build also contacted Peertic’s license service for seat admission. Hosting, model endpoint terms, retention, and integration permissions should be checked for each deployment; see trust and deployment.

What appeared in the PR and portal?

Peertic posted a high severity inline GitHub comment on the affected line and requested changes. Its first check failed. After the test-backed fix, an automated follow-up still treated the old thread as open; an AI assistant checked the test and resolved the sample thread. The final full review posted an approval and successful check. These portal sessions show the initial finding and the final comparison; the bundle contains the GitHub review and check records.

Peertic GitHub PR session showing the high severity concurrent retry finding on src/payments.mjs lines 14 to 15
First GitHub PR run: one finding tied to criterion 1 and the changed code.
Peertic GitHub PR session comparison showing zero new or persisting findings and one resolved finding
Final session comparison: one resolved finding after the full PR review.

What happened in each GitHub review?

1 · Initial PROne high severity finding, changes requested, failing check.
2 · Fix pushedZero new findings, but the earlier thread stayed open because the follow-up did not see the test file.
3 · AI assistant triageAn AI assistant cited the failing and passing concurrency test, resolved the thread, and Peertic returned a neutral check while a bare issue key triggered an unavailable external lookup.
4 · Full reviewAfter the PR description referred only to GitHub issue #1, Peertic reported zero findings, approved the PR, and completed a successful check.

The structured requirement planner recorded the linked issue as unverifiable in every GitHub round. The final approval therefore shows no blocking code finding and a resolved thread; it does not establish that Peertic automatically verified all four acceptance criteria.

Can I inspect or reproduce the example?

Yes. The bundle contains the original GitHub issue, saved first-run requirement context, initial and final PR diffs, GitHub review and check records, all four round outcomes, runnable code, test logs, full local JSON reviews, run metadata, and an evaluation note. The Git bundle preserves the three fixture commits. The sample GitHub repository is private; the bundle is the shareable copy.

Download evidence ZIP
First GitHub session4cd80da2-e169-4352-ad33-b5d519541478
Final GitHub sessioned66a128-b478-4a13-8f9f-3f36916b1977
Local comparison919369cf-951d-47c1-a5a7-b0a5d9b57d85 → ca3da413-6361-45f6-bf2e-aad0f6ca0334

What does this example establish?

This single test case used a purpose-built repository and a deliberately introduced defect; it did not involve customer code or real charges. It shows a linked GitHub issue reaching the first PR review, an actionable inline finding, a reproduced defect, and later GitHub review publication. It does not measure average precision, recall, reliability, or review time savings. The pre-run answer key was written by an AI assistant; independent engineer adjudication is still needed for an evaluation claim.

The first automated GitHub follow-up missed an existing regression test, and an AI assistant resolved the sample thread after checking the code and test. Independent engineer verification remains outstanding. The structured requirement planner could not identify the issue criteria, even when the first code finding cited criterion 1. A configured Jira MCP server failed to initialize, but GitHub issue retrieval and code review completed. The local CLI walkthrough used a file for requirement context and did not itself publish to GitHub.

For data flow and deployment choices, see trust and deployment. For the rest of the product workflow, see pull request review features.