Git on Commentary of Takao

Using SSH Keys instead of GPG keys for Git Commit Signatures

Mon, 25 May 2026 00:00:00 +0900

For a long time, GPG (GNU Privacy Guard) keys were the industry standard for signing Git commits to prove identity and prevent tampering. However, setting up GPG involves generating keyrings, managing expiration dates, and debugging background agents, which introduces substantial friction for developers.

To eliminate this complexity, Git version 2.34 introduced the ability to use your existing SSH keys to sign commits directly, bypassing the need for GPG keys.

In this guide, we will explore how to configure Git to use your SSH keys for signing commits, verify keys locally, and enable trust relationships across development teams.

Recovering Deleted Branches and Commits using git reflog

Sat, 25 Apr 2026 00:00:00 +0900

“I accidentally deleted a local branch using git branch -D,” or “I ran git reset --hard HEAD~1 and lost my unpushed commits!” If you have worked with Git for any length of time, you have likely experienced one of these stomach-dropping moments.

While standard git log commands won’t display references to deleted branches or detached commits, you don’t need to panic. Git has a built-in safety net called git reflog.

Migrating from git checkout to git switch and restore

Wed, 25 Mar 2026 00:00:00 +0900

One of the very first commands developers learn when starting out with Git is git checkout. However, git checkout is a notoriously overloaded command. It handles too many responsibilities, making it a common source of confusion and accidental file loss for beginners and experienced developers alike.

To solve this, Git version 2.23 (released in 2019) introduced two dedicated, task-focused alternatives: git switch and git restore.

In this post, we’ll discuss the design problems surrounding git checkout, explain the roles of the newer commands, and show you how to transition to using them today.

Git Merge vs Git Rebase: Operational Guidelines

Wed, 25 Feb 2026 00:00:00 +0900

When integrating changes from one branch into another in Git, developers generally rely on two primary commands: git merge and git rebase. While both serve the same ultimate purpose—bringing code from two branches together—they approach the problem differently, resulting in vastly different commit histories.

Understanding when and why to use each option is key to keeping your project’s repository clean, readable, and easy to debug.

In this post, we will compare the mechanics, advantages, and drawbacks of git merge and git rebase, and outline a set of operational guidelines for teams.

Conventional Commits for Automated Release Workflows

Sun, 25 Jan 2026 00:00:00 +0900

In a collaborative software development team, inconsistencies in commit message structures can make tracking changes difficult. Vague commit messages like fix bug, update code, or minor changes complicate code auditing and delay release documentation.

To resolve this issue and maintain a clean, machine-readable commit history, developers around the world adopt the Conventional Commits specification.

In this article, we’ll explain the structure of Conventional Commits, standard prefix classifications, and how this discipline enables automated release operations.

Cleaning Orphan Remote Branches with git fetch --prune

Thu, 25 Dec 2025 00:00:00 +0900

In modern development workflows using GitHub or GitLab, feature branches are typically deleted on the remote host as soon as their corresponding pull request (PR) is merged.

However, when you run git branch -a in your local terminal, you will notice that the references pointing to those deleted remote branches (e.g., remotes/origin/feature-xxx) remain in your branch list indefinitely.

This occurs because Git does not automatically sync deletions from remote configurations to your local cache by default.

Undoing Merge Commits Safely using git revert -m

Tue, 25 Nov 2025 00:00:00 +0900

Directly after merging a feature branch into your primary release branch (main), you might discover a severe bug that requires you to immediately roll back the integration.

With standard commits, you can easily undo changes using git revert <commit-hash>. However, attempting to revert a merge commit directly results in a Git error: fatal: commit <hash> is a merge but no -m option was given.

In this guide, we’ll explain why merge reverts require special handling, walk through using the git revert -m option, and reveal the hidden trap of re-merging reverted features later.

Finding Regression Commits Quickly using git bisect

Mon, 20 Oct 2025 00:00:00 +0900

“It worked yesterday, but it is broken today.” In any active software project, regression bugs are bound to slip in. Finding the exact commit that introduced a bug out of hundreds or thousands of commits can feel like searching for a needle in a haystack.

Instead of manually checking out commits one by one or spending hours analyzing code changes, you can use Git’s built-in debugging tool: git bisect.

In this article, we’ll explain how to use the binary search algorithm of git bisect to locate the origin of a bug in minutes.

Signing Git Commits with GPG or SSH and Verified Badges

Thu, 25 Sep 2025 00:00:00 +0900

When reviewing commit logs on GitHub, you’ve likely noticed a green “Verified” badge next to some commits. This label indicates that the commit has been cryptographically signed and confirmed to originate from a legitimate, validated user.

By default, Git allows developers to configure any name and email address they choose using simple commands like git config user.email. This means impersonation is trivial. To guarantee identity authentication and protect against unauthorized contributions, commit signing is highly recommended.

Advanced git stash: Saving Untracked and Restoring Partially

Wed, 20 Aug 2025 00:00:00 +0900

Introduction

In team development, you often need to switch branches to address an urgent bug fix while in the middle of writing code for a feature branch.

While you can commit your half-finished work as a temporary “WIP” commit, a cleaner approach is to use git stash.

This article covers advanced git stash techniques, including saving untracked files, labeling stash items, and restoring specific files from a stash.

1. The Basics of git stash

Let’s review the most common commands:

Ignoring Formatting Commits in git blame with .git-blame-ignore-revs

Sun, 20 Jul 2025 00:00:00 +0900

When auditing a codebase to find out when and why a line of code was introduced, git blame is a developer’s best friend. However, large styling updates, code formatter adoptions (like Prettier), or global linter autofixes can clutter this history. A single bulk reformatting commit can rewrite code authorship labels for the entire repository, hiding the original developers and commits that introduced the actual business logic.

To solve this problem, Git (since version 2.23) introduced a native feature that allows developers to ignore specific commits during blame evaluations: the .git-blame-ignore-revs file.

Using git worktree for Concurrent Branch Development

Tue, 20 May 2025 00:00:00 +0900

Introduction

In daily software development, it is common to get interrupted by an urgent hotfix request while in the middle of writing code for a feature branch.

Traditionally, developers handle this in one of two ways:

Temporarily shelf active changes using git stash, switch branches to fix the bug, commit, switch back, and run git stash pop.
Clone a completely separate copy of the repository into another directory to work on the hotfix.

However, stash runs the risk of conflict errors on restore, and cloning multiple copies of the same repository wastes disk space and complicates local commit synchronization.

Automating Pre-Commit Checks with Husky and Git Hooks

Sun, 20 Apr 2025 00:00:00 +0900

Introduction

In team development, simple mistakes like committing code with syntax errors or bad formatting are common. These issues can break the CI build or lead to messy formatting wars during code reviews.

Instead of relying on developer vigilance to enforce guidelines, you can automate these checks.

By combining Git Hooks with Husky, you can automatically trigger linters (ESLint), formatters (Prettier), and unit tests (Jest) before any commit or push is finalized. This guide walks you through setting up this workflow.

Safe Usecases of git cherry-pick for Specific Commits

Tue, 25 Mar 2025 00:00:00 +0900

Introduction

In team development, you often encounter situations where you need to deploy a specific bug fix from an ongoing feature branch to your production branch (main) immediately, without releasing the half-finished feature itself.

Merging the entire branch would pull in unfinished code.

This is where the git cherry-pick command comes in handy. This article reviews how to safely apply individual commits to a target branch, handle conflicts during execution, and avoid common history pitfalls.

Cleaning Commit History with Interactive Git Rebase

Thu, 20 Feb 2025 00:00:00 +0900

Introduction

During daily software development, it is common to end up with a messy commit history full of logs like “WIP,” “fix typo,” or “testing deployment.”

If you merge these commits directly into your main branch, finding where a specific bug was introduced or understanding why a line of code was added becomes extremely difficult.

Git’s interactive rebase (git rebase -i) allows you to clean up your commit history before creating a pull request. You can squash multiple commits into one, edit commit messages, reorder history, or delete redundant changes. This article covers the step-by-step workflow of utilizing interactive rebasing.

Git Tutorial: From Basics to Advanced Workflows

Sun, 10 Sep 2023 00:00:00 +0900

Git Tutorial: Project Management and Version Control Fundamentals

Git is the de facto standard for version control in modern software development. It tracks every change to your codebase, enables seamless team collaboration, and provides safety nets for experimentation. Whether you are a solo developer maintaining a personal project or part of a large engineering team, mastering Git is essential. This guide covers Git from first principles through advanced workflows, with practical commands and real-world scenarios.