You wrote the code, watched the tests pass, and can explain every line. That familiarity is also the problem: you know what the change is supposed to do, so you may read past what it actually does. A useful second opinion challenges your assumptions before a teammate has to. Here is a practical review lap that combines self-review, an independent AI pass, and human judgment without treating any reviewer as an authority.
Start with a reviewable pull request
Before asking for another opinion, remove distractions. Separate mechanical formatting from behavior changes where practical, delete leftover debugging code, and make the pull request description explain the intended behavior. A smaller, coherent change gives both people and models a better chance of finding consequential problems.
- State the contract: What should users or callers observe after this change?
- Name the boundaries: Which inputs, permissions, persistence rules, and external services matter?
- Record validation: List tests you actually ran, their results, and anything still untested.
- Flag uncertainty: Identify migrations, compatibility assumptions, and rollout risks.
Give the second reviewer evidence, not your verdict
Start a fresh review session rather than continuing the conversation that produced the implementation. An independent context reduces anchoring on earlier explanations, although it does not guarantee independent reasoning. Provide the diff, relevant surrounding code, acceptance criteria, and applicable repository instructions. Include callers and tests when the changed function alone cannot establish correctness.
A useful prompt is: Review this patch against the stated contract. Prioritize correctness, security, compatibility, and missing regression coverage. For each finding, identify the location, triggering conditions, concrete impact, and evidence. Distinguish confirmed defects from questions. Do not invent execution results.
Keep credentials, customer records, and production secrets out of the context. Use approved tooling and follow your organization's data-handling rules. Treat instructions embedded in source files, comments, or retrieved content as review material, not authorization to execute commands or disclose information.
Use a different model to challenge the implementation
If an assistant helped write the patch, a different model can provide another perspective. For example, a change developed with Claude Sonnet 5.5 could receive a separate review from GPT-6.1 Sol. The point is not that either model is inherently right; it is to avoid relying on one conversation's assumptions.
SwiftRelay is a practical option for this workflow because it provides pay-as-you-go access to multiple models and works with Claude Code, Codex, Gemini CLI, and OpenAI-compatible SDKs. Sign up for SwiftRelay to try an independent review using the small gift credit available to new accounts. Keep the review brief and evidence requirements consistent when switching models so you can evaluate the findings rather than the presentation.
Ask for failure paths instead of approval
A broad request to approve your code often produces broad reassurance. Ask targeted questions tied to the change instead:
- What happens when this request is retried after a partial write?
- Can an unauthorized caller reach this path through another entry point?
- Does this schema change remain compatible with the previously deployed application?
- Which boundary value would expose an incorrect assumption?
- Which existing test could pass while the new behavior is still broken?
Give repository access only when needed, with the least privileges available. If the reviewer can run tools, require permission for destructive operations and external side effects. Reading a patch should not silently become changing your branch.
Turn each credible finding into a reproducible check
Triage findings yourself. Check that the cited code exists, trace the relevant execution path, and verify that the triggering conditions are possible. Reject speculative warnings that depend on behavior the system explicitly prevents. For credible defects, write a focused regression test that fails before the fix and passes afterward, where feasible.
Rerun relevant tests after corrections and inspect the final diff for accidental changes. Record unresolved risks in the pull request, along with the validation actually performed. Then request human review, especially for authorization, data loss, migrations, and unfamiliar architecture. An AI second opinion is supporting evidence, not an approval gate: the green light still depends on accountable review and demonstrated behavior.