Quick answer: Start the review from the local git diff, then read the change against the definitions, callers, and imports that surround it rather than judging each line in isolation. The desktop opens the project structure first, then a file shows its full source with views for source, full comparison, and changes. Every finding is tied to reproducible evidence, and you confirm the context before you act.
Open the structure before the diff
When you choose a code folder, the project structure opens first. That ordering matters, because a diff is hard to judge without knowing where the changed files sit and how heavily they are referenced.
Once you open a file, you get its full source and three views:
| View | What it shows |
|---|---|
| Source only | The current file without the diff overlay |
| Full comparison | The before and after together |
| Changes only | Just the added and removed lines |
Added and removed lines are marked, inline character highlights show exactly what changed, and change navigation plus search help you move through a large diff. The review is built on local git differences plus parsers that resolve definitions, callers, and imports.
Read the change with resolved context
A diff in isolation is misleading. The same line means different things depending on the callers and definitions around it, so the review pulls in bounded related context.
- Definitions: the types and functions the change references, so you can see whether a call matches the real signature.
- Callers: who invokes the changed code, which shows how far a modification can ripple.
- Imports: how the file ties into the rest of the system.
Structure filters add more cues. Heavily referenced files flag where a change can spread, temporary-name candidates expose scratch work, identical content points to duplicated blocks, and files with no incoming references deserve a closer look. Treat these as prompts to investigate, not as verdicts.
Verify findings with evidence
As you read, sort each note by its evidence class. Static signals such as typecheck, lint, and build sit alongside dynamic evidence from tests and smoke runs, contract evidence from schema drift, and model-only hypotheses. A model-only claim is always a hypothesis until you verify it.
Each evidence item carries a reproducible command and raw output, so you can rerun the check and confirm the finding. When a script is missing, the result is unverified rather than passed, and an empty result is inconclusive. The deterministic verdict updates only from evidence that actually ran.
A practical reading order helps on a large diff. Start with the changes-only view to see the shape, open the heavily referenced files first, then trace the callers before you read individual lines. That way you understand the blast radius early and only then judge whether each change is safe, instead of forming an opinion before you know how far the change reaches.
Watch the context blind spots
Static resolution cannot see everything. Dynamic loading, framework entry points, and external consumers can be missed, so a file with no incoming references is not automatically safe to delete, and identical text does not prove interchangeable behavior. When a finding depends on a path the parser cannot resolve, mark it for a dynamic test or a smoke run rather than accepting or dismissing it on the spot.
Powerduck shows the diff in context and resolves the surrounding callers, so you can trace a finding to the real definition and confirm it yourself instead of acting on an auto-applied edit.
Frequently asked questions
Why open the structure before reading the diff? The structure tells you how heavily a file is referenced and where the change can ripple, which is context you need before judging individual lines.
Which view is best for a quick pass? Changes only narrows the surface, but switch to full comparison and source views to confirm the surrounding behavior before you decide.
Can I trust a finding without reading the callers? No. Resolve the callers and definitions first, especially for model-only hypotheses, and rerun the reproducible command to confirm the evidence.
The bottom line
A reliable PR review starts with the git diff but depends on the context around it. Open the structure, move between source, comparison, and changes views, and read the resolved definitions, callers, and imports before you judge a line. Verify each finding against its reproducible command, keep the static blind spots in mind, and remember the review does not prove correctness. The diff tells you what moved; the context tells you whether it matters. Continue in the AI code review guide.
