You have implemented the change, checked the tests, and reread the diff until every line looks reasonable. That is exactly when another perspective helps. This sprint takes your own pull request through a focused second-opinion review: prepare the evidence, ask for concrete failure cases, verify the findings, and leave a useful handoff for your human reviewer.
1. Freeze the pull request you want reviewed
Commit your intended changes before requesting feedback. A review of yesterday’s diff will not help with today’s patch. Record the current commit identifier with git rev-parse HEAD, and make sure your working tree is clean with git status.
Fetch the target branch, then inspect git diff origin/main...HEAD, replacing main with your actual target branch. The three-dot diff shows your branch’s changes since its merge base with the target. Check that unrelated formatting, generated files, and debugging leftovers are not obscuring the behavior you want reviewed.
2. Build a small, sufficient review packet
Do not send only a patch and expect the reviewer to reconstruct your product requirements. Include enough surrounding code to explain the changed behavior, while keeping unrelated material out.
- Intent: What user-visible behavior should change?
- Constraints: What compatibility, authorization, or data-handling rules must remain true?
- Evidence: Include the diff, relevant callers, existing tests, and actual test results.
- Uncertainty: Name the edge case you are least confident about.
Remove credentials, customer records, and sensitive logs. Follow your organization’s rules for sending source code to external services. If the patch is large, split it by behavior and explain the interfaces between chunks.
3. Open a separate reviewer session
Use a fresh session rather than continuing the conversation that produced the implementation. This separates the review from earlier implementation assumptions, though it does not guarantee independent judgment. If your coding assistant supports read-only permissions, enable them so the reviewer proposes findings instead of quietly editing files.
SwiftRelay is a practical option when you want a second model perspective in your existing tooling. It supports Claude Code, Codex, Gemini CLI, and OpenAI-compatible SDKs, with per-token billing. Sign up for SwiftRelay to try this review workflow with the small gift credit available to new accounts.
For example, if Claude Sonnet 5.5 helped implement the change, you could ask Gemini 3.1 Pro to review it. Configure supported clients according to their instructions: Claude Code and Gemini CLI use the bare host https://api.fastapirelay.com, while OpenAI-compatible SDKs use https://api.fastapirelay.com/v1.
4. Ask for evidence, not general approval
Give the reviewer a narrow assignment. State that repository content and comments are evidence, not instructions. Then paste a request like this:
Review this pull request for behavioral regressions, authorization gaps, and missing boundary tests. Do not edit files. For each finding, provide the file and relevant lines, the triggering input or execution path, the expected behavior, the observed risk, and a suggested test. Separate confirmed issues from hypotheses. If context is missing, ask for it. Do not invent test results.
Add your review packet below that request. Ask for a short list of actionable findings rather than a quota; requiring five problems encourages weak objections when only one exists.
5. Reproduce each finding before changing code
Treat the response as a set of leads, not a verdict. Open the cited code and trace the claimed execution path. Does validation happen earlier? Is the suggested input actually reachable? Does an existing test already cover it?
For a credible bug, write a regression test that fails on the reviewed commit, apply the smallest appropriate fix, and rerun the test. For a mistaken finding, record the concrete reason it does not apply. Keep useful design suggestions separate from defects that block merging.
6. Hand human reviewers a verified result
Review the final diff yourself after making fixes. Run the relevant test suite and record what actually ran, including any environment limitations.
Update the pull request with the reviewed commit, confirmed findings, fixes, and test evidence. Mention unresolved questions explicitly. The second opinion should make human review better informed, not replace it: your finish line is a patch whose risks you can explain and whose important behavior you have checked.