How to make a coding agent review diffs before a PR

How can I make my coding agent review diffs before it opens a pull request

Make the agent finish work on a branch first, then force a self-review step against the diff, then open the pull request only after the agent has fixed what it found. GitHub’s Copilot cloud agent docs describe this exact shape: research, plan, iterate on code changes on a branch, and review the diff before deciding to open a pull request.

The part people get wrong is asking the agent to open the pull request first and review later. That gives you a noisy PR, makes the review slower, and turns the PR into the place where basic mistakes are discovered. A cleaner workflow is: branch, change, diff review, fix, test, then open the PR. GitHub’s PR guidance also says self-review should include reading the diff and checking that relevant builds or tests have run.

If your agent supports task steps, put the review requirement into the task itself. Tell it to compare its working branch against the target branch, list every changed file, point out accidental edits, and explain any behavior change in plain language. GitHub’s review docs recommend reviewing one file at a time, which fits well with an agent that can pause on each file instead of dumping a single broad summary.

A practical prompt looks like this: “Before opening a pull request, review the full diff against main, list risky files, check for missing tests, and fix anything that would surprise a reviewer. Do not create the PR until the review checklist is complete.” That keeps the review inside the agent’s workflow instead of making it an optional follow-up after the PR already exists. GitHub’s Copilot docs say iterative changes on a branch let you review and refine work before opening the PR.

Use two checks, not one. First, have the agent review the diff for correctness, accidental scope creep, and test gaps. Second, run the branch locally or in a cloud workspace and inspect the result yourself. GitHub’s self-review guidance says to read the diff and verify builds or tests, and its Copilot review guidance still treats the human review as the real gate.

If the change is large, split it before the review. GitHub’s stacked pull request guide says each layer should stay a clean, self-contained diff, and each layer should be reviewed on its own. That matters because agents are good at summarizing a branch, but much less reliable when one PR mixes feature work, cleanup, and test changes in the same patch.

A simple pattern is: ask the agent to implement on a feature branch, then ask it to review the staged diff and answer four questions. What changed, what is risky, what tests were added or updated, and what should a reviewer inspect first. After that, have it fix the issues it found, rerun tests, and only then open the PR. GitHub’s review flow is built around the Files changed tab, line comments, and a final approve or request-changes decision, so this sequence maps cleanly onto the normal review process.

The inconvenient part is that the agent cannot honestly review what it cannot see. If your workflow opens a PR from a remote service before the branch is finalized, move the review step earlier. If your agent runs from a local repo, make it compare HEAD to the base branch, because that is the actual diff reviewers will see later. The review must happen on the same content that will become the pull request.

A good gate is a pre-PR checklist the agent must satisfy: diff reviewed, risky files named, tests run, accidental changes checked, and a short summary written for the human reviewer. GitHub’s docs explicitly recommend giving reviewers context, explaining what changed and where to pay attention, and reviewing your own PR first. Using the agent for that step makes the eventual PR easier to trust, not just easier to create.

If you want a tool-specific shortcut, GitHub’s UI and CLI both support creating drafts, but the cleaner move is still to postpone PR creation until after the diff review. GitHub Desktop shows a preview diff before creation, and GitHub CLI supports draft PRs, which can help, but the real control point is the agent instruction, not the button. In other words, make “review first” part of the task contract.

For teams using Copilot cloud agent, the best practice is to let it research, plan, and iterate on code changes on a branch first, then review the diff before opening the PR. That is the nearest documented pattern to what you want. If the agent can also produce a short handoff note, even better, because the human reviewer then starts with a branch summary instead of a raw blob of changed files.

A concrete flow that works is: create branch, assign task, wait for code changes, ask the agent to review its own diff, apply fixes, run tests, then open a draft or normal pull request. If the review finds a hidden behavior change, keep the branch open and make the agent explain the exact line that caused it. That is the point where agents save time, because they catch the obvious mistakes before a teammate has to.

If you are building this into an internal script, the control should live before the PR creation call, not after it. The script can run the agent review step, fail fast if the diff checklist is incomplete, and only then call the pull request API or CLI. That keeps the review as a gate instead of a comment thread attached to work that is already public.

For more on the platform context around agent workflows, testing, and sharing work on DevConnect, see https://devconnectplatform.com. The main idea is the same across tools: let the agent inspect the diff while the branch is still private, then open the pull request only after the branch has been cleaned up and verified.