How to Write Shell Helper Functions That Save You Time Every Day

Shell helper functions turn multi-step commands into single words. Instead of remembering IP addresses, typing out long git sequences, or navigating deep directory trees manually, you define a function once in your shell config and use it forever. This guide covers practical shell helper functions organized by what they actually solve: server access, git workflows, project navigation, and dev environment shortcuts. Every example works in both Bash and Zsh. If you want to streamline your dev environment further, check out our guide to deploying with GitHub Actions.

Aliases vs Shell Helper Functions

An alias replaces one string with another. A function accepts arguments, runs logic, and handles complex operations. Use aliases for simple command substitutions. Use functions for anything that takes parameters or needs conditional behavior.

Feature	Alias	Function
Accepts arguments	No (appended to end only)	Yes ($1, $2, etc.)
Conditional logic	No	Yes (if, case, loops)
Multi-line commands	Awkward	Natural
Local variables	No	Yes (local keyword)
Best for	alias ll='ls -la'	Anything with parameters

Both syntaxes work in Bash and Zsh:

# Alias — simple substitution
alias gs='git status'

# Function — accepts arguments
greset() {
  git checkout -- "$1"
}

Where to Put Your Functions

Add functions to ~/.zshrc (Zsh) or ~/.bashrc (Bash). These files run automatically every time you open a new terminal. After editing, reload with source ~/.zshrc or source ~/.bashrc to apply changes without opening a new window.

If your config file gets long, split functions into a separate file and source it:

# In ~/.zshrc
source ~/.shell_functions

This keeps your main config clean and makes functions easier to version-control or share across machines.

SSH Shortcut Functions

Remembering IP addresses, ports, and usernames for every server gets old fast. A single function can map friendly names to full SSH commands.

srv() {
  case "$1" in
    production)  ssh [email protected] -p 2222 ;;
    staging)     ssh [email protected] -p 2222 ;;
    database)    ssh [email protected] ;;
    *)           echo "Unknown server: $1"
                 echo "Available: production, staging, database" ;;
  esac
}

Now srv production connects to your production box. The wildcard * case prints available options if you mistype a name or forget what’s configured. You can extend this with more servers as your infrastructure grows.

For simpler setups, SSH config (~/.ssh/config) handles host aliases natively. But functions give you more flexibility: conditional logic, port forwarding flags per environment, or chaining commands after connection.

Git Helper Functions

Git commands you run 20 times a day are worth wrapping in functions, especially the multi-step ones.

# Stage everything, commit with message, push
gcp() {
  git add -A && git commit -m "$1" && git push
}

# Create and switch to a new branch
gnew() {
  git checkout -b "$1"
}

# Delete a branch locally and remotely
gnuke() {
  local branch="$1"
  git branch -d "$branch" 2>/dev/null
  git push origin --delete "$branch" 2>/dev/null
  echo "Deleted branch: $branch"
}

gcp "fix login bug" replaces three separate commands. gnew feature/auth creates and switches in one step. gnuke uses the local keyword to avoid leaking the branch variable into your shell session. The 2>/dev/null suppresses error messages if the branch doesn’t exist on one side.

Project Navigation Functions

Jumping between project directories is faster with shortcuts than typing full paths.

# Jump to a project by name
p() {
  local dir="$HOME/projects/$1"
  if [ -d "$dir" ]; then
    cd "$dir" || return
  else
    echo "Project not found: $1"
    echo "Available:"
    ls "$HOME/projects/"
  fi
}

# Create a directory and cd into it
mkcd() {
  mkdir -p "$1" && cd "$1" || return
}

p myapp jumps to ~/projects/myapp. If the project doesn’t exist, it lists what’s available so you can see what you misspelled. mkcd combines two commands that almost always run back-to-back. The -p flag creates parent directories if needed.

Dev Environment Functions

Functions that handle repetitive dev tasks save the most time over a typical workday.

# Kill whatever's running on a port
killport() {
  local pid
  pid=$(lsof -ti :"$1")
  if [ -n "$pid" ]; then
    kill -9 "$pid"
    echo "Killed process $pid on port $1"
  else
    echo "Nothing running on port $1"
  fi
}

# Quick file search in current directory
f() {
  find . -name "*$1*" 2>/dev/null
}

# Get your public IP
myip() {
  curl -s https://ifconfig.me
}

killport 3000 finds and kills whatever process is hogging port 3000 — useful when a dev server crashes and leaves a zombie process. f config searches for any file with “config” in its name. myip returns your public IP without opening a browser. Each function does exactly one thing and takes less than five seconds to type.

For more developer workflow automation, our vibe coding best practices guide covers how to integrate AI tools into your development process alongside these manual shortcuts.

Frequently Asked Questions

Recommended Dev Gear

Long coding sessions are easier with a mechanical keyboard that handles fast typing, headphones that block distractions, and a monitor with enough real estate for terminal and editor side by side.

Summary

Shell helper functions are one of the highest-return productivity investments you can make as a developer. Start with the SSH shortcut pattern to map server names to IPs, add a few git helpers for the commands you run constantly, and build out from there. Keep each function short, use local for variables, and store everything in ~/.zshrc or a sourced file. The time you spend writing these functions comes back every single day.