On a Mac, resolve a cherry-pick conflict by editing each conflicted file in Terminal or a code editor, staging the finished files with git add, and running git cherry-pick --continue. Git pauses because it could not apply a commit cleanly; your current branch has not yet received that commit. Review both sides of each conflict before continuing, and use git cherry-pick --abort if you decide not to proceed. Git’s cherry-pick documentation describes this paused state and its continuation options.

1. Open Terminal in the project folder

Open Terminal from Spotlight or Finder’s Applications > Utilities folder. In Terminal, move to the repository folder with cd and its path. For a folder path containing spaces, quote the path, for example cd "/Users/sam/Work/My Project". You can also type cd with a trailing space, drag the project folder from Finder into the Terminal window, then press Return. Apple describes Terminal as macOS’s command-line interface; its prompt often ends with % when using the default zsh shell. Apple’s Terminal guide explains how to open it and recognize the prompt.

Confirm you are in the repository and see what Git reports before changing files:

git status

If the output says a cherry-pick is in progress and names conflicted paths, continue below. If you are unsure which repository or commit is involved, stop and confirm that context before resolving anything. Do not start a second cherry-pick while the first is paused.

2. Inspect the conflict and decide what the file should contain

Open each conflicted text file in your editor. Git inserts markers around sections it could not reconcile. A typical section looks like this:

<<<<<<< HEAD
content on the current branch
=======
content from the commit being cherry-picked
>>>>>>> commit subject or identifier

HEAD is the current branch’s version; the other section is from the commit being applied. These labels describe the two sides of this operation, but they do not tell you which version is correct. Use the surrounding code, the intended change, and the commit’s purpose to decide whether to keep one side or combine them. Git’s documentation explains that conflicted files contain markers and that paths applied cleanly may already be updated. Git cherry-pick

Edit the file so it contains the intended result, removing all conflict-marker lines. Check every conflict in that file, save it, and repeat for every path listed by git status. For a binary file or a conflict whose intended result is unclear, do not guess: consult the change’s author or project guidance before choosing a version. Avoid replacing a whole file with one side simply to make the conflict disappear; that can discard valid changes.

3. Stage the resolutions and review them

After resolving a file, tell Git that its conflict is resolved by staging it. Use the exact path shown by git status; quote paths that contain spaces:

git add "Sources/Example File.swift"

Repeat for each resolved path. git add stages the file’s current contents, so review what you are staging if it contains unrelated edits. Git’s git-add manual documents that it adds file contents to the index, the staging area used for the next commit. Git add

Check whether any conflicts remain and inspect the staged resolution:

git status
git diff --cached

git status should no longer list unresolved paths. Read the staged diff and confirm both that the intended change is present and that conflict markers or accidental edits are absent. git diff --cached shows staged changes; Git diff documents this review option. If you find a mistake, edit the file, stage it again, and review the diff once more.

4. Continue the cherry-pick

When all conflicts are resolved and staged, run:

git cherry-pick --continue

Git resumes the paused operation and, when successful, records the cherry-picked change as a new commit. If Git opens an editor for the commit message, save and close it using that editor’s normal controls. Then check git status and review the latest commit if needed:

git status
git log -1 --oneline

For a sequence of cherry-picked commits, --continue proceeds with the operation; a later commit may also stop for conflicts. Resolve and stage that commit’s conflicts the same way. Git documents --continue for resuming a failed cherry-pick and --skip for omitting the current commit. Use --skip only when you intentionally want to omit that commit’s change, not as a shortcut for unresolved files. Git cherry-pick options

If you want to stop instead

If you decide the cherry-pick should not proceed, run git cherry-pick --abort. Git documents this as canceling the operation and returning to the state before the sequence began. If you had local work before starting, check it afterward with git status; do not use destructive reset commands as a substitute for understanding the current state. Git cherry-pick

A useful stopping rule is simple: continue only after you understand the intended content of every conflicted file and have reviewed the staged result. If the code’s intent is unclear, preserve the paused state and ask for project-specific guidance before creating the commit.

Sources