How to Use the Essential Git and GitHub Cheatsheet

What are we building and why?

We are assembling an authoritative, deterministic Git and GitHub CLI command cheatsheet. This reference organizes high-frequency commands across repository initialization, staging, branch isolation, stashing, history inspection, remote synchronization, and pull request automation.

Searching through scattered documentation or trying to remember arcane command flags wastes developer time. Legacy tutorials frequently recommend outdated commands like git checkout for both branch switching and file restoration, causing accidental file overwrites. Modern Git commands provide clear, single-purpose semantics that prevent mistakes.

At ZeroShot Studio, we structured this cheatsheet as the operational standard for all our developers and autonomous coding agents, ensuring identical, error-free command execution.

flowchart TD
    Task[Engineering Task] --> Category{Command Domain}
    Category -->|Branch & Switch| BranchCmd[git switch -c / git switch]
    Category -->|Stage & Commit| CommitCmd[git add / git commit -m]
    Category -->|Undo & Restore| RestoreCmd[git restore / git revert]
    Category -->|Inspect & Diff| LogCmd[git log --graph --oneline]
    Category -->|GitHub CLI Automation| GHCmd[gh pr / gh repo / gh issue]

Engineering teams and autonomous coding assistants standardize on these version control practices to ensure predictable repository operations across local and remote environments.

The operational trade-off of adopting modern commands (git switch, git restore) is unlearning legacy git checkout habits. However, modern syntax prevents catastrophic accidental file overwrites.

Related reading: GitHub CLI Setup and the Git Learning Stack. Authority specifications: GitHub Git Cheatsheet Guide and Git SCM Reference.

"Consistency across terminal environments is the foundation of autonomous software delivery."

We established this standard at ZeroShot Studio after evaluating agent failure modes across hundreds of CI runs. Standardizing command-line procedures turns fragile manual steps into a reliable automated baseline.

What are the required prerequisites?

Before executing this recipe, verify your host environment satisfies the following minimum requirements:

• Operating System: Linux (Ubuntu 22.04+ LTS, Debian 12+), macOS 13+, or WSL2 on Windows
• Shell Environment: Bash 5.0+ or Zsh 5.8+ with standard POSIX utilities
• Version Control: Git 2.38+ installed and configured
• CLI Utilities: GitHub CLI (gh) 2.40+ authenticated
• Network Permissions: Outbound HTTPS (Port 443) and SSH (Port 22) access

Verifying local Git configuration and workspace prerequisites upfront eliminates merge anomalies and unexpected prompt blocks during automated tasks.

How do you implement the step-by-step recipe?

Follow these sequential steps to implement the workflow deterministically:

1. Repository Setup and Configuration. Initialize, clone, and configure environments:

git init                   # Initialize new local repogit clone                        # Clone remote repogit config --global user.name 'Name' # Set author namegit config --global user.email 'mail'# Set author emailgit config --global pull.ff only     # Enforce fast-forward pulls

2. Branch Management and Worktree Navigation. Create, switch, list, and delete branches:

git switch -c           # Create and switch to new branchgit switch              # Switch to existing branchgit branch -a                         # List all local and remote branchesgit branch -d           # Delete merged branchgit branch -D           # Force-delete unmerged branch

3. Staging, Committing, and Undoing Changes. Stage, commit, inspect status, and restore files:

git status -s                         # Short status summarygit add                         # Stage specific filegit add -p                            # Interactively stage chunksgit commit -m 'type: description'    # Create commitgit restore                     # Discard uncommitted working tree changesgit restore --staged            # Unstage file without losing changes

4. Stashing Temporary Work. Save uncommitted work without committing:

git stash push -m 'WIP message'      # Stash working directory changesgit stash list                        # View active stashesgit stash pop                         # Apply and remove latest stash

5. History Inspection and Diffing. Explore commit topology and inspect code diffs:

git log --oneline --graph -n 10       # Compact commit graphgit diff                              # Show unstaged modificationsgit diff --staged                     # Show staged modificationsgit show                 # Inspect specific commit diff

6. GitHub CLI Operational Shortcuts. Automate GitHub platform actions directly from terminal:

gh repo create  --public --clone # Create and clone GitHub repogh pr create --fill                  # Open PR using commit titlesgh pr merge --squash --delete-branch  # Squash merge PR and delete branchgh issue list --state open            # List open repo issues

How do you verify the deployment works?

To verify that the deployment completed successfully and all configurations are active, run the following verification suite:

git log --oneline -n 1 && gh --version | head -n 1

Expected output:

a1b2c3d chore: initial commitgh version 2.45.0 (linux/amd64)

Running this verification suite asserts that repository settings and branch tracking are configured correctly without interactive blocks.

What are the common production failure modes?

When operating in production environments, watch out for these recurring pitfalls:

• Accidental branch discard with checkout: Running git checkout overwriting local edits when intending to switch branches. Use git switch for branches and git restore for files.
• Force-pushing over teammates' commits: Running git push -f obliterates remote history. Always use git push --force-with-lease if force-pushing is required.
• Unrecovered dropped stashes: Running git stash drop on uncommitted work. Recover dropped stashes using git fsck --lost-found if executed recently.

How can AI agents execute this directly?

Autonomous coding assistants running in Cursor, Claude Code, Windsurf, or OpenClaw can execute this entire workflow using the companion skill manifest below:

name: use-the-essential-git-and-github-cheatsheetdescription: Deterministic runbook for how to use the essential git and github cheatsheet.## Execution Rules1. Repository Setup and Configuration.2. Branch Management and Worktree Navigation.3. Staging, Committing, and Undoing Changes.4. Stashing Temporary Work.5. History Inspection and Diffing.6. GitHub CLI Operational Shortcuts.

Integrating explicit execution manifests ensures reproducible Git branching, ignoring, and editor behavior across all autonomous agents.

FAQ

Why did Git introduce git switch and git restore? In Git 2.23, git checkout was split into git switch (for branches) and git restore (for files) to eliminate confusion and prevent accidental data loss.

What is the difference between git merge and git rebase? git merge creates a non-linear merge commit joining two histories; git rebase replays your commits linearly on top of upstream.

How do I undo the most recent commit while keeping my changes? Run git reset --soft HEAD~1.