# Manufacture Review Independence > Use when reviewing your own work, or when the author-equals-reviewer guard is deliberately overridden — real independence is gone, so manufacture it: parallel independently-scoped sub-reviews plus an adversarial re-read of source for every high-severity claim, and treat cross-reviewer disagreement as a pointer to the boundary file that settles it. Triggers on "self-review", "review my own PR", "author is the reviewer", "no one else can review", "code review my changes", and conflicting review findings. - Skill: `iamakbarsha1/manufacture-review-independence` (Agent Skill) - Install (CLI): `npx skillmds@latest add iamakbarsha1/manufacture-review-independence` - Raw SKILL.md: https://api.skillmd.com/api/skills/iamakbarsha1/manufacture-review-independence/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: iamakbarsha1 (https://skillmd.com/u/iamakbarsha1) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/iamakbarsha1/manufacture-review-independence --- # Manufacture Review Independence **Type:** Open-source — client-agnostic methodology, no project-specific detail. **Created by akbarsha — https://github.com/iamakbarsha1** Distilled from self-review situations where the author was also the reviewer, and from parallel reviewers giving conflicting severities because the deciding file sat outside both their scopes. **Licence:** Released under CC BY 4.0 — share and adapt for any purpose with credit. Full text: `LICENSE` at the repository root. **Feedback & Support:** If a rule here proves wrong or needs sharpening, open an issue on the repository or contact the author at the profile link above. If the problem is the agent not following a rule below rather than the rule itself, that's an execution failure — acknowledge and correct it. ## The core rule A review's value comes from independence. When author and reviewer are the same (or the same model, same context, same session), that independence is gone and leniency creeps in. Don't pretend the review is independent — MANUFACTURE independence structurally: split the work into independently- scoped sub-reviews, run an adversarial pass whose job is to refute each high-severity claim by re-reading the source, and when two views disagree, resolve it by reading the file that decides — never by averaging. ## Checks - **Split into independently-scoped sub-reviews.** Instead of one lenient pass over everything, review in separate scoped passes (security, correctness, contract-boundaries, tests) each blind to the others' conclusions, then merge. Different scopes surface what a single sympathetic read glosses over. *(Illustrative: A combined pass over a multi-tenant export feature missed a missing tenant-scoping check; rerunning the same diff as a dedicated security-only pass caught it immediately, because that pass wasn't also weighing style.)* - **Adversarially re-read source for every high-severity claim.** For each High/Critical finding, run a pass whose explicit goal is to REFUTE it by reading the actual code, and default to "not real" if the source doesn't confirm it. This kills both the author's blind spots and plausible-but-false findings. A claim that survives a genuine refutation attempt is worth acting on. *(Illustrative: A finding claimed a race condition from the diff alone; an adversarial re-read of the full function showed a mutex already guarded the section, and the finding was dropped.)* - **Disagreement points to the boundary file — go read it.** When two reviewers (or two passes) assign conflicting severity to the same fact, that gap is not noise to average away; it means the deciding evidence lives in a file NEITHER of them fully read. Identify that boundary file, read it, and let it settle the call. *(Two parallel reviewers rated the same issue High and Low; the truth lived in a shared module outside both their assigned scopes — reading it resolved the conflict decisively.)* - **For security/correctness-critical code, iterate adversaries until they converge.** After your own tests pass, run independent adversarial passes — each a distinct attack lens (encoding, casing, framing, boundary) — and require each to EMPIRICALLY confirm a bypass by running the code, not theorize one. Feed every confirmed bypass back as a regression test and re-run; the stop condition is convergence — rounds that surface only ceilings you've consciously accepted — not a single clean round. *(A fail-closed secret scrubber passed all its author-written tests, but four rounds of parallel adversaries each found real high-severity bypasses the tests never imagined — UUID-shaped tokens, uppercase/short hex, narrow-wrapped PEM bodies — until the rounds converged on documented, accepted ceilings.)* ## Pre-flight check — before you trust a self-review - [ ] The review ran as multiple independently-scoped passes, not one sympathetic read. - [ ] Every High/Critical finding survived an adversarial re-read of the actual source (or was dropped). - [ ] Any cross-reviewer disagreement was resolved by reading the deciding boundary file, not by averaging severities. - [ ] For security/correctness-critical code, adversarial passes ran until they converged on accepted ceilings — not stopped at the first clean round — and each confirmed bypass became a regression test. If any box is unchecked, the review inherited the author's blind spots — go manufacture the independence.