Most developers already have more tools than they can use well. Editors, linters, package managers, and browser extensions pile up over the years, and many of them add setup time, configuration files, and one more thing to remember. The best productivity tools work differently. They remove small points of friction, such as searching a codebase slowly, retyping the same directory path, or switching windows to check a pull request, and then they get out of the way. This guide covers ten utilities that do exactly that, along with practical notes on where each one fits and where it doesn't.
Ripgrep for fast code search
Searching a large repository with plain grep works, but it gets slow and noisy as the project grows. Ripgrep (rg) is built for source code. It respects .gitignore by default, skips binary files, and searches in parallel, so results usually appear almost instantly even in large monorepos.
# Find every function named parse_config in Python files
rg -t py "def parse_config"
# List files that contain a TODO, without the matching lines
rg -l "TODO"
The main trade-off is that ripgrep is a search tool, not a replacement for language-aware navigation. When you need to find every call to a function across a typed codebase, your editor's symbol search is more accurate. For everything else, from logs to config files, ripgrep is hard to beat.
fzf for interactive filtering
fzf is a general-purpose fuzzy finder that reads lists from standard input and lets you narrow them down by typing a few characters. Combined with other commands, it turns vague memory into a precise selection. Opening a file you half remember becomes a matter of seconds.
# Open a file chosen interactively in your editor
vim $(fzf)
# Pipe Git branches into fzf and check one out
git checkout $(git branch | fzf)
fzf works best when you use it as a building block rather than a single command. Its shell key bindings, such as searching command history with Ctrl+R, are often the first thing developers come to rely on. The learning curve is small, but customizing it heavily can become a hobby of its own, so keep the defaults until you have a specific need.
zoxide for smarter directory jumps
Typing cd ~/work/clients/acme/services/billing dozens of times a week is a waste of attention. zoxide tracks the directories you visit and lets you jump to them with a short partial name. It ranks matches by how often and how recently you use them, so the paths you care about rise to the top.
# Add this to your shell configuration file (Bash example)
eval "$(zoxide init bash)"
# After visiting the billing directory once or twice
z billing
zoxide does not replace project-aware tools like workspace managers. Its strength is speed for ad hoc navigation, and it works the same way in any terminal session.
direnv for per-project environments
Many productivity problems come from environment drift. One project needs Node 18, another needs Node 22, and a third expects a specific API key to be loaded. direnv loads and unloads environment variables automatically when you enter and leave a directory, based on a file named .envrc.
# .envrc in a project root
export NODE_ENV=development
export DATABASE_URL="postgres://localhost:5432/app_dev"
layout python3
# Enable the hook in your shell, then approve the file once
eval "$(direnv hook bash)"
direnv allow
Because .envrc runs as shell code, it should be treated with the same care as any script. Never commit secrets into it. Store sensitive values in a password manager or a secret store, and let the file reference them.
jq for working with JSON
APIs return JSON, and reading it raw in a terminal is tedious. jq is a command-line JSON processor that filters, reshapes, and formats data in a single pipeline. It fits neatly into shell scripts and quick debugging sessions alike.
# Fetch a repository and print only its star count
curl -s https://api.github.com/repos/cli/cli | jq '.stargazers_count'
# Extract the names of open issues from a saved response file
jq -r '.[] | select(.state == "open") | .title' issues.json
The syntax has a learning curve, and complex transformations can become hard to read. For very large files, a streaming approach or a language-specific parser may be a better choice. For day-to-day inspection, jq saves a surprising amount of time.
HTTPie for readable API requests
When you test an endpoint, curl is powerful but verbose. HTTPie offers a simpler syntax, colored output, and automatic JSON handling. It is particularly pleasant when you are exploring an unfamiliar API or sending a quick request during debugging.
# Send a JSON POST request without writing headers by hand
http POST api.example.com/items name=widget price:=12.5
# Add an authorization header
http GET api.example.com/me Authorization:"Bearer $TOKEN"
HTTPie is not a full testing framework. Once you need repeatable test suites, shared collections, or automated checks in CI, a dedicated tool or a test runner in your language will serve you better.
lazygit for visual Git workflows
Git is essential, but many of its commands are easy to misremember. lazygit wraps common operations in a terminal interface that shows the status of your files, branches, and commit history at once. Staging individual lines, rebasing interactively, and resolving conflicts become visual tasks rather than memorized commands.
Open it from inside any repository by running lazygit. Staging, committing, and switching branches happen through keyboard shortcuts listed on screen. lazygit does not replace understanding Git. It makes routine work faster and leaves the underlying concepts intact, which is a healthy balance for most teams.
GitHub CLI for pull requests without the browser
Switching to a browser to create or review a pull request breaks focus. The GitHub CLI (gh) brings those actions into the terminal, where you are already working. It can open pull requests, check their status, and check out a reviewer's branch in seconds.
# Create a pull request using the title and body from your commits
gh pr create --fill
# Check out someone else's pull request locally
gh pr checkout 42
# View checks and review status for the current branch
gh pr status
Authentication happens once through gh auth login. For teams that rely heavily on GitHub, this tool removes many small context switches each day.
tmux for persistent terminal sessions
tmux lets you split a terminal into panes and windows, and it keeps sessions running even when you disconnect. This is valuable for long builds, remote servers, and multi-service development setups where you want a dev server, a test watcher, and a log viewer visible at once.
# Start a named session for an API project
tmux new -s api
# Reattach later, even after closing the terminal window
tmux attach -t api
tmux has a steep initial learning curve, and its keyboard shortcuts take practice. Its value grows the more you rely on remote machines or long-running processes, so it is worth learning when you first need it rather than on day one.
pre-commit for consistent code quality
Formatting and linting problems are a common source of noisy code review comments. pre-commit runs configured checks automatically before each commit, catching trailing whitespace, formatting drift, and common mistakes before they reach a pull request. Many teams use it to keep reviews focused on logic instead of style.
# .pre-commit-config.yaml
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v4.6.0
hooks:
- id: trailing-whitespace
- id: end-of-file-fixer
pre-commit install
pre-commit run --all-files
The main cost is that hooks can slow down commits if they are heavy. Keep the checks fast, and move slow analysis into continuous integration when needed.
Dotfiles and shell aliases for repeated commands
The tools above are most useful when your shell is set up to use them comfortably. Keeping your shell configuration, aliases, and editor settings in a version-controlled repository, often called a dotfiles repository, means a new machine can be configured in minutes instead of days. It also documents your habits, which helps when you pair with a colleague.
Start small. Add aliases only for commands you type daily, and resist the temptation to build an elaborate setup on day one. A few well-chosen shortcuts will do more for your daily workflow than a long list of rarely used ones.
Choosing tools without adding complexity
Each tool in this list solves a specific friction point, and none of them requires a major change in how you work. That is the common thread. Before adopting a new utility, ask three questions. Does it remove a repeated, concrete annoyance? Can you learn its core use in under an hour? Will the rest of your team benefit, or at least not be disrupted by it?
If the answer to all three is yes, try it on a single project for a week. If it still helps, keep it. If it becomes another thing to maintain, remove it without guilt. Productivity comes from a small set of tools you understand well, not from the largest collection.
Final thoughts
Productivity tools are most valuable when they fade into the background. Ripgrep, fzf, zoxide, and direnv remove navigation and setup overhead. jq, HTTPie, lazygit, and GitHub CLI shorten the loop between writing code and checking it. tmux, pre-commit, and a tidy dotfiles repository make your environment dependable across projects and machines. Pick two or three from this list that match your biggest daily frustration, learn them properly, and build from there. Your future self, reviewing code at the end of a long week, will notice the difference.
Top comments (0)