Learn Git - Advanced History Navigation (Cherry-Pick, Reflog & Bisect)

#Introduction

In episode 16 we learned to rewrite history with interactive rebase. In episode 17 we learn to read and rescue history: taking one commit from another branch with git cherry-pick, recovering seemingly lost commits through git reflog, and automatically finding the commit that caused a bug with git bisect.

These abilities are life-savers in the real world. Have you ever accidentally deleted a branch that contained a week of work? Or had a bug appear "suddenly" with no one knowing which commit it started from? This episode answers both — while reaffirming one important fact: Git almost never deletes data permanently.

#Cherry-Pick: Taking a Specific Commit

Sometimes you only need a single commit from a branch — not the whole branch. Example: the hotfix fix: perbaiki bug login lives on the feature/auth branch, but main also needs that fix right now.

git switch main
git cherry-pick a1b2c3d

git cherry-pick copies the changes of a commit to the active branch as a new commit with a new SHA — the original commit on the other branch stays intact. It is a shortcut for spreading an important fix without merging the entire branch.

#Conflicts in Cherry-Pick

If the copied changes clash with files on the target branch, Git stops and shows conflict markers (remember episode 7). Resolve them like a normal merge conflict, then continue:

git add resolusi.txt
git cherry-pick --continue

If you want to cancel everything: git cherry-pick --abort.

#Reflog: The History of HEAD Movement

git log only shows the history of commits. git reflog shows the history of HEAD movement — every event in the repository: checkout, commit, reset, amend, merge, even rebase:

a1b2c3d HEAD@{0}: checkout: moving from feature-x to main
e4f5g6h HEAD@{1}: commit: fix: perbaiki validasi login
i7j8k9l HEAD@{2}: commit: feat: tambah halaman dashboard
f1f2f3f HEAD@{3}: reset: moving to f1f2f3f
c9c8c7c HEAD@{4}: rebase: finished

Each line records the destination commit SHA, the HEAD position at that time, and the action that triggered it. This is why a reset commit or a deleted branch can still be found: their traces remain stored in the reflog.

#Rescuing a Deleted Commit or Branch

The most common example: git branch -D feature-x turns out to have deleted a week of work. Stay calm, the commit is still alive in the reflog. Find its SHA, then recreate the branch:

git reflog
git switch -c feature-x a1b2c3d

To move the active branch back to an old commit:

git branch -f main a1b2c3d
git switch main

#Bisect: Finding the Commit That Caused a Bug

A bug appears and no one knows since when. git bisect finds it with binary search: it marks half of the history, checks whether the bug is there, then narrows down until one suspect commit remains.

git bisect start
git bisect bad HEAD
git bisect good v1.0.0

Git then checks out a commit in the middle. You test: if the bug is still present, mark git bisect bad; if clean, mark git bisect good. Every answer halves the candidates. A few steps later one commit remains — that is the culprit.

#Automating with git bisect run

For bugs that can be tested automatically, let Git run the loop itself:

git bisect start
git bisect bad HEAD
git bisect good v1.0.0
git bisect run bun run test

Or use a custom script cek-bug.sh that exits with code 0 (good) or non-zero (bad):

#!/bin/sh
./jalankan_aplikasi
if grep -q "BUG" log.txt; then
  exit 1
else
  exit 0
fi

When done, return HEAD to its position:

git bisect reset

#Closing

The points to take with you:

• git cherry-pick <hash> copies one commit's changes to the active branch as a new commit.
• git reflog records every HEAD movement — the emergency path to find commits that were reset, amended, or deleted.
• A deleted branch can be restored with git switch -c <name> <sha> from the reflog.
• git bisect finds the bug-causing commit with binary search; git bisect run <script> does it automatically.
• The reflog is not permanent — secure valuable commits promptly.

History can now be tidied up and navigated. Time to talk scale: how to combine many repositories into one project. In the next episode 18 we cover Git Submodules & Subtrees for managing multi-repository dependencies. See you in episode 18!