Great work!

XP to next level

BugEater
EN Login
EN

Git Surgery for QA: Rewriting History, Bisect & Recovery

Advanced All professions 576 XP 8h 45min

Updated: 11/09/2026

Start Trail

You can branch, merge and survive a conflict. Now learn the operations that edit history itself — rebase, cherry-pick, revert, reflog and bisect — so a messy branch becomes clean, a lost commit comes back, and a regression is located in six commands instead of an afternoon.

Where This Trail Picks Up

Two trails brought you here. The first made the terminal ordinary: init, add, commit, log, push. The second made a team survivable: branches, merges, conflicts, stash, blame, Pull Requests.

Both of those treated history as something that happens to you. You added commits to the end of it and read it afterwards.

This trail treats history as something you operate on. Commits can be reordered, collapsed, reworded, moved between branches, undone, and — when it all goes sideways — recovered from a journal Git keeps whether you asked it to or not. These are the commands developers use daily and are quietly astonished that testers know.

There is one QA superpower waiting at the end of it. git bisect turns "this worked last month and doesn't now" from a guessing game into a binary search that a script can run for you while you get coffee. Nothing else in this trail changes a tester's day as much.

What You'll Learn

Eight modules, four lessons each:

  1. Rebasing vs. Merging — the two ways to bring a branch up to date, what each does to the graph, and the golden rule that keeps rebase from wrecking a shared branch.
  2. Interactive Rebase & History Cleanup — git rebase -i and the todo list: squash, fixup, reword, edit, drop and reordering, so a branch arrives at review readable.
  3. Cherry-Picking — moving one specific fix without dragging a whole branch behind it, and putting a hotfix on a test environment in a hurry.
  4. Undo Mechanics — git revert for what is already published, reset --soft/--mixed/--hard for what is not, and where git restore fits.
  5. Disaster Recovery with Reflog — the journal of everywhere HEAD has been, and how it brings back a "deleted" branch or a commit you rebased into oblivion.
  6. Binary-Search Debugging — git bisect by hand, then git bisect run with a test script doing the deciding.
  7. Clean Repositories, Ignoring & Submodules — .gitignore, .gitkeep, git clean -fd, and what a submodule is when the automation lives in a repo of its own.
  8. Git Hooks & Automation for QA — pre-commit and pre-push hooks that run linters and tests before anything leaves your machine, and why CI is still the real gate.

Every lesson ends with a quiz worth 12 XP. Finish a module and its circular badge is yours; finish all eight and the History Surgeon square badge is yours too.

Who Is This For?

QA engineers — manual or automation — who have finished Git Foundations for QA and Git Teamwork for QA, or who branch and merge comfortably but have never run rebase -i, have never recovered anything with reflog, and would not know where to start with a "it broke somewhere in the last 200 commits" ticket.

No programming is required. Module 6 and Module 8 use a shell script of about five lines, and both are given to you in full.

How to Get the Most Out of It

Every command here is practised in a scratch repository, not on your team's. Make one, generate twenty junk commits, and then break it deliberately: squash the wrong things, hard-reset a branch you cared about, delete it, and bring it back with the reflog. The confidence this trail is trying to give you comes from having destroyed something and recovered it while nothing was at stake.

Interactive challenges for these modules are coming to the platform later. The lessons are written so nothing depends on them.

By the end, "the history is a mess and I don't know how it got that way" is a solvable problem rather than a fact of life.

Modules

Rebasing vs. Merging

Two commands bring a stale branch up to date, and they produce completely different histories. This module makes the choice deliberate instead of habitual — and teaches the one rule that makes rebase safe.

72 XP 1h Not started

Interactive Rebase & History Cleanup

A branch with nine commits called "wip", "fix", "fix again" and "actually fix" is a branch nobody wants to review. Interactive rebase turns that into three commits that read like a decision log.

72 XP 1h Not started

Cherry-Picking

Sometimes you need exactly one commit from a branch and absolutely nothing else. git cherry-pick copies that single commit anywhere you want it, and it is the fastest way to get a hotfix onto a test environment.

72 XP 1h Not started

Undo Mechanics: Reset, Revert, Restore

Git has three different commands for "undo" and they are not interchangeable. Choosing the wrong one in front of a colleague is embarrassing; choosing the wrong one on a shared branch is an incident.

72 XP 1h Not started

Disaster Recovery with Reflog

The panic moment — a branch deleted, a rebase gone wrong, a reset --hard on the wrong branch — is almost never the disaster it feels like. Git wrote down everywhere HEAD has been, and the way back is usually two commands.

72 XP 1h Not started

Binary-Search Debugging with git bisect

"It worked in the January build and it doesn't now" describes about four hundred commits. git bisect finds the guilty one in around nine steps, and with a test script it finds it while you are away from your desk.

72 XP 1h Not started

Clean Repositories, Ignoring & Submodules

A repository fills up with build output, screenshots, node_modules and — eventually — someone's API key. This module is about what should never be committed, how to remove what already is, and what happens when your test suite lives in a repository of its own.

72 XP 1h Not started

Git Hooks & Automation for QA

A hook is a script Git runs at a specific moment — before a commit is written, before a push leaves your machine. It is the cheapest quality gate in existence, and it runs before CI has even heard about your branch.

72 XP 1h Not started