SCM Breeze: Supercharging Your Git Workflow

Introduction

I've been using Git for a few years now, and while it's an amazing tool, the command-line workflow can be tedious. How many times have you done this?

$ git status
# On branch master
# Changes not staged for commit:
#   modified:   app/controllers/users_controller.rb
#   modified:   app/views/users/show.html.erb
#   modified:   config/routes.rb

$ git add app/controllers/users_controller.rb
$ git add app/views/users/show.html.erb

All that typing! Especially when you have deeply nested file paths. I recently discovered a tool called SCM Breeze that solves this problem elegantly.

What is SCM Breeze?

SCM Breeze is a collection of shell scripts (for bash and zsh) created by Nathan Broadbent. Released last October, it enhances your git workflow by adding numbered file shortcuts, keyboard bindings, and smart repository navigation.

The core idea is simple but powerful: when you run git status, each file gets a number. You can then reference files by their numbers in subsequent git commands. No more typing long paths.

Installation

Installation is straightforward. Clone the repository and run the install script:

git clone git://github.com/ndbroadbent/scm_breeze.git ~/.scm_breeze
~/.scm_breeze/install.sh
source ~/.bashrc  # or ~/.zshrc if you use zsh

The install script adds configuration to your shell profile. After reloading your shell, SCM Breeze is ready to use.

Numbered File Shortcuts

This is the killer feature. Run git status (or just gs – SCM Breeze adds aliases):

$ gs
# On branch master
# Changes not staged for commit:
#
#       modified: [1] app/controllers/users_controller.rb
#       modified: [2] app/views/users/show.html.erb
#       modified: [3] config/routes.rb
#
no changes added to commit

See those numbers? Now you can use them in git commands:

$ ga 1 2          # git add files 1 and 2
$ gd 3            # git diff file 3
$ gco 1           # git checkout file 1

You can even use ranges:

$ ga 1-3          # Add files 1, 2, and 3
$ ga *            # Add all files

This is a massive time-saver. No more autocomplete, no more copying and pasting paths, no more typos in long file names.

Git Aliases

SCM Breeze comes with sensible git aliases:

gs      # git status
ga      # git add
gd      # git diff
gc      # git commit
gco     # git checkout
gb      # git branch
gl      # git log
gp      # git push
gpl     # git pull
gm      # git merge

These are standard enough that they become muscle memory quickly, but short enough to speed up your workflow significantly.

Repository Index

If you work on multiple projects, the repository index feature is invaluable. It builds an index of your git repositories and lets you jump between them quickly.

First, add your projects directory:

$ git_index --rebuild ~/projects
Indexing: /Users/you/projects/
  => Found 15 repositories

Now you can use c (for "change directory") with tab completion:

$ c my-app<TAB>
$ c my-app-frontend    # Jumps directly to ~/projects/my-app-frontend

It's like autojump, but specifically for git repositories. You can be anywhere in your filesystem and instantly jump to any project.

List all indexed repositories:

$ git_index --list
1: ~/projects/blog
2: ~/projects/my-app-frontend
3: ~/projects/my-app-backend
...

Or jump by number:

$ c 2    # Jump to ~/projects/my-app-frontend

Keyboard Bindings

SCM Breeze adds keyboard shortcuts for common git operations:

Ctrl+x, c – Commit with message
Ctrl+x, s – Git status
Ctrl+x, space – Git add

These work in bash/zsh command line editing. For example, Ctrl+x c opens a prompt where you can type your commit message, then commits the staged files.

I'll be honest – I don't use these as much as the numbered shortcuts, but they're handy for quick commits.

Shell Integration

SCM Breeze enhances your shell prompt to show git information:

[master|✔] ~/projects/my-app $

The ✔ indicates a clean working directory. If you have changes, you'll see different indicators:

[master|●1 ✚2] ~/projects/my-app $

This means 1 modified file and 2 untracked files. It's useful at a glance, though I've customized my prompt to be less cluttered.

Practical Workflow Example

Here's how I use SCM Breeze in a typical workflow:

# Jump to project from anywhere
$ c my-app

# Check status
$ gs
# On branch feature-login
# Changes not staged for commit:
#
#       modified: [1] app/models/user.rb
#       modified: [2] app/controllers/sessions_controller.rb
#       modified: [3] spec/models/user_spec.rb
#
# Untracked files:
#
#   [4] app/views/sessions/new.html.erb

# Add the files I want
$ ga 1 2 4

# Check the diff before committing
$ gd --cached

# Commit
$ gc -m "Add login functionality"

# Push
$ gp origin feature-login

Notice how much faster this is than typing full paths. The numbered shortcuts eliminate so much friction.

Working with Multiple Files

When you have many changes, SCM Breeze really shines:

$ gs
# 15 modified files...
#       modified: [1] file1.rb
#       modified: [2] file2.rb
#       ...
#       modified: [15] file15.rb

# Add files 1-10 in one command
$ ga 1-10

# Or add specific files
$ ga 1 3 5 7 9

# Or add everything
$ ga *

This is so much better than git add . (which stages everything) or typing out individual paths.

Git Branch Management

SCM Breeze improves branch management too:

$ gb
# Lists branches with numbers:
#   [1] master
#   [2] feature-login
# * [3] feature-signup
#   [4] hotfix-bug

# Switch branches by number
$ gco 1    # Checkout master

You can also delete branches by number:

$ gb -d 4    # Delete branch 4

Design Assets Management

SCM Breeze includes a feature for managing design assets, though I haven't used it much. The idea is you can keep design files (PSDs, wireframes, etc.) in a separate directory that syncs across machines without bloating your git repository.

This might be useful for designer-developer collaboration, but I typically use Dropbox or similar for design files.

Configuration

SCM Breeze is configurable. Edit ~/.scm_breeze/scm_breeze.config:

# Number of repository shortcuts
export git_status_shortcuts_no_less=1

# Custom git aliases
git_alias "alias_name" "command"

# Disable features you don't want
export git_keyboard_shortcuts_enabled=0

I've customized mine to disable some features I don't use and adjusted the prompt format.

Compatibility

SCM Breeze works with:

bash (tested on Linux and Mac)
zsh (my preferred shell)
Git 1.7+ (basically any modern Git version)

I use it on Mac OS X with zsh, and it works flawlessly. I've also tested it on Ubuntu and had no issues.

Performance

One concern with shell enhancements is performance. SCM Breeze is pretty fast – the numbered file list generation is nearly instant, even with hundreds of files.

The repository index rebuild can take a minute if you have many repositories, but you only do that once. Navigation after that is instant.

Downsides

A few minor issues:

Learning curve: It takes a day or two to retrain your muscle memory to use numbers instead of tab-completion. But once you do, you won't go back.

Terminal multiplexer quirks: If you use screen or tmux, you need to make sure your shell config is sourced properly in each pane.

Not portable: The numbered shortcuts only work on machines where you've installed SCM Breeze. If you SSH into servers frequently, you'll need to remember the standard git commands too.

Alias conflicts: If you already have custom aliases, there might be conflicts. The install script checks for this, but you may need to adjust.

Alternatives

Other tools in this space:

Git aliases: You can create your own aliases in ~/.gitconfig, but they don't have the numbered shortcut magic.

Hub: GitHub's git wrapper adds extra commands, but doesn't improve the basic git workflow like SCM Breeze does.

tig: A text-mode interface for git. More visual than SCM Breeze, but different use case.

Magit: The Emacs git interface. Amazing if you use Emacs, but not a shell enhancement.

SCM Breeze is unique in its approach of enhancing the command-line git experience without replacing it.

Should You Use It?

If you:

Work with git on the command line regularly
Find yourself typing long file paths repeatedly
Work on multiple projects and navigate between them often
Want to speed up your git workflow

Then yes, absolutely try SCM Breeze. Give it a week to get used to the numbered shortcuts. I guarantee you'll be more productive.

If you use a GUI for git (like GitX, Tower, or SourceTree), or if you rarely use git from the command line, SCM Breeze probably won't add much value.

Installation Tips

After installing, spend 10 minutes just running gs and practicing the numbered shortcuts. Muscle memory builds quickly.

Customize the aliases if they conflict with your existing ones. The defaults are sensible, but your workflow might differ.

If you don't like a feature (like the keyboard bindings), disable it in the config. Use only what helps you.

In Summary

SCM Breeze has become an essential part of my development workflow. The numbered file shortcuts alone justify the installation. Being able to run ga 1-5 instead of typing out five file paths saves me dozens of keystrokes per day.

The repository index is a close second – jumping between projects instantly is a huge productivity boost when you're context-switching frequently.

It's not perfect, and there's a learning curve, but the payoff is worth it. If you spend significant time with git on the command line, SCM Breeze will make you faster and happier.

Check it out at: https://github.com/ndbroadbent/scm_breeze

Give it a week, and let me know what you think. I bet you'll wonder how you ever lived without numbered git shortcuts.