Most developers spend hours each week wrestling with Git. Not because they’re bad at their jobs, but because Git doesn’t actively teach you its most powerful features.

At GitKon 2025, our Senior Product Marketing Manager Jonathan Silva revealed 6 underused Git commands that solve the workflow problems developers face every day: botched rebases, lost commits, and merge conflict chaos.

These aren’t advanced techniques. These are practical commands for those “oh no, what did I just do?” moments.

1. Undo Your Last Commit Without Losing Work

The Problem: You committed too early. Wrong message, forgot a file, or need one more quick change.

The Solution:

bash

git reset --soft HEAD~1

This undoes your last commit but keeps everything staged. Your code is untouched and ready to recommit.

• HEAD~1 goes back one commit (use HEAD2, HEAD3 to go further)
• --soft keeps your changes staged
• --hard would nuke everything (avoid this unless you’re sure)

Quick tip: Use git revert for changes you’ve already pushed and shared. Use git reset --soft for local fixes before pushing.

In GitKraken Desktop, right-click any commit and choose “Soft Reset” to remove the commit while keeping changes staged.

2. Recover “Lost” Commits with Git Reflog

The Problem: You deleted a branch, reset too far, or made changes in detached HEAD state. The work seems gone forever.

The Reality: Git forgets nothing for 30-90 days.

bash

git reflog

This shows your private timeline of every HEAD movement, including commits that vanished from git log.

Recovery process:

1. Run git reflog to see your timeline
2. Find the lost commit hash
3. git checkout <commit-hash> to view it
4. git checkout -b recovery-branch to save it

This command has saved thousands of developers from botched rebases and deleted branches.

In GitKraken Desktop, click Terminal, run git reflog, and watch the commit graph update side-by-side as you navigate your history.

3. Cherry-Pick Without Committing Immediately

The Problem: You need changes from a specific commit but aren’t ready to commit them yet.

The Solution:

bash

git cherry-pick -n <commit-hash>

The -n flag (or --no-commit) pulls the changeset into your working directory without creating a commit. Perfect for:

• Building complex feature branches from multiple sources
• Modifying cherry-picked code before committing
• Combining changes strategically

In GitKraken Desktop, right-click any commit, select Cherry-pick, and choose “No” when asked about immediate commit. Changes land in your working directory for further editing.

4. Actually Navigate Your Stash

The Problem: Your stash is a junk drawer where changes go to die.

The Reality: Git stashes are numbered and fully navigable.

bash

git stash list                 # See all stashes
git stash pop stash@{2}        # Apply and remove specific stash
git stash apply stash@{1}      # Apply but keep stash for later

Pro tip: Name your stashes when creating them:

bash

git stash push -m "WIP: user auth before hotfix"

Now git stash list shows descriptions instead of cryptic references.

In GitKraken Desktop, type a description in the WIP field before creating a stash. Right-click any stash to see its contents, then pop or apply as needed.

5. See Who’s Actually Writing Code

The Problem: You need to know who has context on legacy code or who maintains a specific module.

The Solution:

bash

git shortlog -sne

This breaks down commits by author with name, email, and count.

When this is useful:

• Identifying active contributors in open source projects
• Finding who wrote legacy code and might have context
• Understanding team contribution patterns
• Knowing who to ask about specific areas

Caveat: Commit count isn’t everything. Some developers make frequent small commits, others make infrequent large ones. Use this as a starting point, not a definitive measure.

In GitKraken Desktop, click the gear icon on the commit graph and enable Author filtering. Search for any contributor and highlight their commits throughout history.

6. Multi-Repo Workflows (Bonus)

The Problem: Modern development spans multiple repositories, but Git forces single-repo thinking.

GitKraken CLI Solution:

bash

gk work start feature-branch    # Start work item across repos
gk work add                     # Add current repo to work item
gk work commit --ai             # Commit across all repos

One command, multiple repositories, cohesive commit messages.

The GitKraken CLI comes bundled with GitLens for VS Code. After installing, search for “GitKraken MCP” to complete setup.

The Pattern: Reducing Git Fear

All these commands share a theme: they reduce anxiety around Git operations.

When you know you can recover lost commits, you’re less afraid to experiment. When you can undo commits safely, you commit more freely. When you control your stash, you feel confident instead of chaotic.

Git anxiety comes from feeling one wrong command away from disaster. These techniques are your safety net, transforming Git from a tool you nervously interact with into one you confidently control.

Start With One Command

Pick the command that solves your most frequent pain point. Use it until it becomes second nature. Then add another.

You don’t need to become a Git wizard overnight. You just need to expand your toolkit one command at a time until Git stops fighting you and starts working for you.

Watch Jonathan’s full GitKon session on our YouTube channel for step-by-step demos and additional context on when to use each technique.

Quick Links:

• Git Fundamentals Course
• Download GitKraken Desktop
• Watch Full GitKon Session

Have your own underused Git command? Share it with us on Twitter or LinkedIn.