The Small CLI Toolkit Worth Learning

You do not need dozens of command-line tools. Recognize a small set, then learn each one when a real course or project creates the need.

Git, SSH, curl, ripgrep, find, jq, and GitHub CLI cover seven useful roles: version history, remote access, data transfer, content search, file search, JSON processing, and GitHub workflows. They are a learning queue, not an installation checklist.

Choose a problem before a tool

For each proposed tool, answer:

• What current task requires it?
• Is it already required by a course or project?
• What simpler built-in tool can handle today’s task?
• Which official documentation defines the behavior?
• What harmless exercise will demonstrate success?
• What credentials, network access, or file changes are involved?

Install only what the course or task requires. A dormant tool still adds update, security, and troubleshooting obligations.

The seven roles

These roles overlap at their boundaries. Git can use SSH for remote repository access. curl can retrieve JSON that jq processes. GitHub CLI works with GitHub, while Git manages the local repository history. Understanding the boundaries prevents one tool from becoming a vague answer to every task.

Git: inspect and record project history

Git tracks versions of project content and supports comparison among working files, staged changes, and commits.

Learn Git when a programming course or project needs:

• a visible change history;
• a checkpoint before an experiment;
• line-by-line review;
• branches or collaboration; or
• submission through a Git-based workflow.

Begin with inspection: git status, git diff, and log viewing. Then learn how the course expects changes to be staged and committed. The official Git reference is the canonical command documentation.

Git is not a general backup of every file on the computer. It protects only the content actually recorded in its repository history.

SSH: connect to a remote system

OpenSSH’s ssh client supports login and command execution on a remote machine over an encrypted connection. Learn it when a course gives you a server account or a project requires an approved remote host.

Important first concepts include:

• the remote hostname and account;
• host-key verification;
• authentication and private-key protection;
• the distinction between local and remote paths; and
• how to end the session.

The OpenSSH ssh manual documents current client behavior and warns about sensitive key files and agent forwarding.

Do not practice against an arbitrary internet host. Use a system and account you are authorized to access.

curl: transfer data identified by a URL

curl is a command-line tool for transferring data with URL syntax. It is useful for inspecting an HTTP response, downloading an approved file, or calling a documented web API.

Learn curl when you must:

• retrieve a course resource from an authoritative URL;
• inspect response headers;
• send a documented API request; or
• make a transfer reproducible.

Start with a harmless public resource and visible output. Do not send tokens, private data, or downloaded content until you understand the URL, method, headers, body, destination, and certificate behavior. Use the official curl manual and built-in help.

ripgrep: search file contents

ripgrep, invoked as rg, searches file contents for a pattern. Its official project guide explains that it reports matching lines.

Use it when a project contains many text files and you need to find:

• an error message;
• a function or configuration name;
• a citation or phrase; or
• every occurrence before a careful change.

Default filtering matters. The project documentation states that ripgrep normally respects ignore rules and skips hidden and binary files. An empty result does not prove that no matching bytes exist anywhere.

find: find files and directories

find searches filesystem entries by name and related criteria. It answers “Where is the file?” while ripgrep usually answers “Which file contains this text?”

The POSIX find specification documents the portable utility and its expression-based search. Learn it when you need to locate files or directories across a project or system.

Begin with display-only searches. find can be combined with actions such as execution or deletion, so do not add an action until you have inspected every match and understand the scope.

jq: select and transform JSON

jq is a command-line JSON processor. It understands JSON structure, so it can select fields and transform arrays without treating the input as an arbitrary visual string.

Learn jq when an API, tool, or project produces JSON and you need to:

• pretty-print it;
• select named fields;
• filter records;
• reshape a result; or
• feed a smaller JSON result into another documented step.

Start with a saved, nonprivate sample. Validate that the input is JSON and compare record counts before and after filtering. Use the official jq manual for the installed version.

GitHub CLI: operate GitHub from a terminal

GitHub CLI, invoked as gh, provides commands for GitHub repositories, issues, pull requests, workflow runs, and other GitHub services. It does not replace Git’s local version history.

Learn it when a real GitHub workflow becomes repetitive or when a course documents its use. Authentication and repository scope matter. Inspect the current repository and planned action before creating, closing, merging, or changing anything.

The official GitHub CLI manual documents commands and authentication-related behavior.

Build a personal learning queue

Create:

# CLI Learning Queue

## Tool

Problem it solves:
Current need:
Why the current tool is insufficient:
Official documentation:
Harmless first exercise:
Evidence of success:
Credentials or risks:
Decision: learn now | defer

Add all seven tools, but promote at most two to learn now. A strong entry is specific:

## ripgrep

Problem it solves: Search text across a programming project.
Current need: Find every use of an outdated configuration name.
Official documentation: project guide
Harmless first exercise: Search a disposable project for a known phrase.
Evidence of success: Find the three prepared matches and no ignored-file claim.
Decision: learn now

“Useful someday” belongs in defer.

Common mistakes

• Installing the whole list. Start from current work.
• Confusing Git with GitHub CLI. Local history and hosting workflows are related but distinct.
• Using SSH without verifying the host. Confirm authorization and identity.
• Downloading and executing in one step. Inspect retrieved content first.
• Assuming search has the defaults you expect. Check the tool’s path, filtering, and traversal behavior before relying on the result.
• Parsing JSON as visual columns. Use a structure-aware tool.
• Putting credentials in command arguments or notes. Follow official secure authentication guidance.

Do this now

Create the queue. Choose one current problem and one harmless exercise. Use the official documentation to inspect help and verify the tool’s role. Defer every tool that lacks a current task.

Log what you learned

Record only:

• Result: What did the action produce?
• Evidence: What observation, test, or source supports that result?
• Next action or unresolved question: What should happen next?