GitGlow logoGitGlow
Download

AI coding workflow · reviewed October 3, 2026

How to review Codex and ChatGPT code changes before committing

Find the files that actually changed, read the diff, test the resulting behavior, and decide what belongs in the commit. The starting point depends on whether Codex edited a local checkout, delivered a cloud task through a pull request, or you copied a code suggestion from ChatGPT.

Download GitGlow Free

Everyday diff review and staging are Free. File review marks, checkout verification, and managed agent runs require Pro. OpenAI access and provider usage are separate.

1. Locate the actual changes

Codex in a local checkout or worktree

Open the exact folder where the task made edits. A Codex worktree has its own working files, so your usual checkout may show no changes. Confirm the path, branch or detached HEAD, and pending files before reviewing.

git rev-parse --show-toplevel
git status --short --branch
git diff --stat
git diff
git diff --cached

Inspect untracked files separately; ordinary git diff does not include their contents. In GitGlow, select that checkout and open Changes. Read the worktree guide.

Codex cloud changes delivered through a PR

Read the PR’s base, head commit, changed files, and checks. To inspect or test locally, fetch the PR branch and open it in a separate checkout so you preserve unrelated work. Already committed changes need a revision comparison; an empty working-tree diff does not mean the PR is empty.

Compare the PR’s merge base with its head. In a terminal, replace the example refs with the PR’s actual target and fetched branch:

git diff --stat origin/main...codex/task-branch
git diff origin/main...codex/task-branch

Read revision comparisons. OpenAI’s Codex Cloud documentation describes inspecting task changes and check results before opening a PR.

Code suggestions copied from ChatGPT

If you copied a snippet or applied a suggested patch, review the files after you applied it. Check where the snippet fits, which imports it needs, and whether it assumes APIs or dependencies your project does not use. A code block in a conversation is not a local Git change until it reaches your files.

2. Inspect the patch in context

Read every affected file, including tests, configuration, lockfiles, and generated output. Check callers when a function signature changes. Review error handling, data boundaries, and edits outside the requested task. The task summary can explain intent; the diff shows what will ship.

A supported local Codex connection can add run and attributed-file context in Agent Observatory. Git status still provides the inventory of pending work, and attribution does not prove correctness. Check the Codex connection requirements.

Sample repository capture. Use the file inventory and selected diff together; this is not a recording of a Codex task.

3. Review a concrete example

Suppose you asked Codex to fix a search box that keeps showing old results after you clear the query. The patch changes the input handler, adds a test, updates a lockfile, and touches a README you were editing.

  1. Input handler: confirm that an empty query clears results. Check that a slower response for an earlier query cannot put those results back.
  2. Regression test: verify that it exercises clearing the field and the delayed response. A test that only asserts the new helper’s return value may miss the actual interaction.
  3. Lockfile: identify whether the fix needs a dependency change. Resolve unexplained dependency edits before including them.
  4. README: preserve your unrelated edits and leave them out of this commit. If changes share a file, stage the relevant hunks or supported lines.

For a ChatGPT snippet, also inspect the surrounding input state and request lifecycle after you paste it. This example illustrates review decisions; GitGlow does not automatically establish that the search behavior is correct.

4. Test the current code

Run the regression test, affected checks, and required lint or build in the checkout you reviewed. Exercise the search interaction in the example above. For a cloud PR, check that CI ran on the current head; local checks may need the project’s setup and dependencies.

GitGlow Pro offers file review marks and configured checkout verification. Later edits can invalidate marks and make previous verification stale. If Codex changes another file after your check, reread the affected diff and rerun checks that could be affected. Read review confidence and verification.

5. Prepare the commit or PR

For local edits, stage the reviewed implementation and relevant tests, then read the staged diff. GitGlow Free supports staging files, hunks, and supported selected lines. Read staging controls.

git diff --cached --stat
git diff --cached
git status --short

For a PR whose changes are already committed, finish the revision review and current checks, then follow the repository’s merge process. Publishing or merging needs its own decision; reviewing a patch does not perform either action.

Common questions

Do I need an OpenAI connection to review the diff?

No. Review local Git changes without an agent connection. A supported Codex connection adds activity context. Code you paste from ChatGPT can be reviewed as ordinary file edits.

Can GitGlow manage every Codex or ChatGPT session?

Managed Codex runs and observed local sessions have separate connection requirements. Observed sessions remain owned by their originating client. This guide does not claim a connection to arbitrary ChatGPT conversations or Codex cloud tasks. Read managed-run capabilities.

Why can’t I see my Codex changes in my usual folder?

The task may have edited a separate worktree, or the changes may already be committed on another branch. Confirm the task’s checkout and head commit. OpenAI’s worktree documentation explains how separate checkouts work.

Does this review process work with Claude Code too?

Yes. See the Claude Code review guide for its connection context, or browse all workflow guides.