Not every graphical tool needs replacing, but for developers and system administrators who spend much of their working day inside a terminal, there comes a point when opening another application, switching windows, and navigating through menus starts to feel unnecessary. Projects such as xh, k9s, lazydocker, lazygit, pgcli, yazi, btop, and zellij show that many everyday development and administration tasks can be handled directly from the command line, often with the additional advantage of being scriptable and automation-friendly.

The key CLI tools in 20 seconds

Many terminal tools are not intended to completely replace GUI applications, but to make repetitive tasks faster.
xh handles API requests, k9s manages Kubernetes, and lazydocker provides an interactive view of Docker.
lazygit and gh cover a large part of everyday Git and GitHub workflows.
pgcli and mycli bring autocomplete and improved interaction to PostgreSQL and MySQL.
yazi, btop, lnav, and zellij turn the terminal into a much more complete working environment.

This is not about returning to some form of command-line purism. Graphical interfaces are still clearly better for discovering unfamiliar systems, collaborating with non-technical users, or performing tasks only occasionally.

The difference becomes noticeable when the same operation is repeated ten, twenty, or fifty times a day.

At that point, typing a command can be considerably faster than launching an entire application.

From Postman and Kubernetes to Docker without leaving the terminal

1. xh: test APIs without opening Postman

xh is an HTTP client written in Rust with syntax inspired by HTTPie. It is designed to make HTTP requests from the terminal without requiring the more verbose syntax sometimes associated with traditional command-line clients.

A POST request can look like this:

xh POST api.example.com/orders \
  items:='[{"sku":"SKU-1042","qty":2}]' \
  Authorization:"Bearer $API_TOKEN"Code language: JavaScript (javascript)

For a backend developer who simply needs to test an endpoint, the advantage is straightforward: the request runs in the same terminal where application logs may already be visible.

That does not make Postman unnecessary. Shared collections, mock servers, documentation, and collaborative workflows remain valuable for teams that need a common interface.

2. k9s: Kubernetes in terminal mode

k9s provides a terminal user interface (TUI) for inspecting and managing Kubernetes clusters.

For example:

k9s -n production

From there, administrators can inspect pods, namespaces, logs, and other resources without continuously chaining together kubectl commands.

This is particularly useful during incidents because information is refreshed in real time while the operator remains inside the same terminal session.

3. lazydocker: a TUI for Docker

lazydocker provides an interactive terminal interface for containers, images, logs, and resource usage.

Starting it is as simple as:

lazydocker

It can be useful for people who already rely heavily on the Docker CLI but still want a persistent overview of their containers without opening Docker Desktop.

That does not mean Docker Desktop has become irrelevant. Beyond its graphical container management interface, it integrates several components of the Docker environment and greatly simplifies container development on Windows and macOS.

4. dive: understand why a Docker image is so large

dive has a more specific purpose: analysing the layers of Docker and OCI images and showing which files have been added, modified, or removed at each layer.

dive myapp:latestCode language: CSS (css)

It can also be integrated into continuous integration workflows to identify wasted space:

CI=true dive myapp:latestCode language: JavaScript (javascript)

This makes it particularly useful when developers are trying to understand why a container image has unexpectedly grown from a few hundred megabytes to several gigabytes.

Git also has its own terminal desktop

5. lazygit: Git without memorising every command combination

lazygit is one of the better-known terminal user interfaces built around Git.

It allows users to inspect changes, stage files and individual hunks, manage commits and branches, resolve conflicts, and perform rebase operations from a single interface:

lazygit

It does not replace Git itself. Instead, it uses Git underneath and provides an interactive layer on top.

For developers and administrators working through SSH or on remote systems, this can be considerably more convenient than GitHub Desktop or Sourcetree.

6. Hunk: reviewing diffs generated by AI coding agents

Hunk addresses a newer problem: reviewing increasingly large changes generated by coding agents.

Instead of constantly moving between a browser, terminal, and editor, developers can inspect changes directly from their existing command-line workflow.

Typical commands include:

hunk diff

or:

hunk show HEAD

It also provides a watch mode:

hunk diff --watch

This makes it possible to keep a diff visible while an agent continues modifying a repository.

The concept is becoming more relevant as AI coding tools move from suggesting individual lines to modifying multiple files and running larger development tasks autonomously.

7. GitHub CLI: pull requests, issues, and Actions through gh

GitHub’s official CLI covers a substantial part of the everyday GitHub workflow without requiring a browser:

gh pr status
gh pr view 482 --comments
gh run listCode language: PHP (php)

It can also create, review, and merge pull requests, manage issues, and interact with GitHub Actions.

The web interface remains better suited to complex collaborative reviews, but gh works particularly well for quick checks and operations that developers perform repeatedly.

Databases without TablePlus or pgAdmin

8. pgcli: PostgreSQL with autocomplete

pgcli keeps the traditional command-line database experience while adding features such as autocomplete, syntax highlighting, and improved editing.

pgcli postgresql://user@localhost/ordersCode language: JavaScript (javascript)

It can suggest tables, columns, and SQL keywords as queries are written.

9. mycli: the same idea for MySQL and MariaDB

mycli comes from the same dbcli ecosystem and provides a similar experience for MySQL and MariaDB:

mycli mysql://user@localhost/ordersCode language: JavaScript (javascript)

For quick queries against databases an administrator or developer already understands, both tools can save considerable time.

When exploring a large and unfamiliar database schema, however, tools such as TablePlus or pgAdmin can still be faster because relationships and structures can be inspected visually.

Files, processes, and logs also have terminal alternatives

10. yazi: a file manager inside the terminal

yazi is a fast terminal file manager written in Rust, with keyboard-driven navigation and file previews.

yazi

It allows users to browse directories, preview files, and perform common filesystem operations without leaving the terminal.

This is particularly useful when working through SSH, where opening a traditional graphical file manager may not even be an option.

11. btop: CPU, RAM, storage, and network in one screen

btop provides an interactive overview of system resources:

btop

It displays processes, CPU utilisation, memory, storage, and network activity.

It is not intended to replace a centralised monitoring or observability platform. Its strength is rapid local diagnostics, especially on servers where installing a graphical interface would make little sense.

12. lnav: navigate and query logs

lnav, short for Log File Navigator, can combine multiple log files into a single interactive view:

lnav /var/log/app/*.logCode language: JavaScript (javascript)

One of its more interesting capabilities is support for querying log data using SQL.

That makes it quite different from tools such as tail, less, or grep. Rather than simply displaying lines, it can recognise structured log formats and help administrators correlate events across multiple files.

Notifications and persistent terminal sessions

13. ntfy: notifications from scripts using HTTP

Receiving a notification when a job finishes does not necessarily require a Slack bot.

ntfy can publish notifications over HTTP and deliver them to desktop or mobile clients.

For example:

curl -d "Backup completed" ntfy.sh/my-serverCode language: JavaScript (javascript)

The software can also be self-hosted, which makes it particularly interesting for infrastructure teams that want to keep notifications under their own control.

Possible uses include backups, CI jobs, monitoring scripts, and long-running maintenance tasks.

14. zellij: multiple terminals inside one terminal

zellij is a terminal multiplexer conceptually similar to tmux.

It can be started with:

zellij

or a named working session can be created and attached with:

zellij attach --create work

Users can divide a single session into multiple panes and tabs and return to that environment later.

A typical setup might look like this:

┌──────────────────────┬──────────────────────┐
│                      │                      │
│      lazygit         │     application      │
│                      │        logs          │
├──────────────────────┼──────────────────────┤
│                                             │
│                  shell                      │
│                                             │
└─────────────────────────────────────────────┘

For newcomers, zellij can also be easier to approach than tmux because its interface displays keyboard shortcuts directly on screen.

15. Coding agents also fit naturally into this workflow

The final component in many modern terminal environments is an AI coding agent running directly from the command line.

There is no single option here. Claude Code, Codex, and other tools have moved capabilities that were once primarily associated with IDE-integrated assistants into the terminal.

The main difference from a traditional chat interface is that these agents can work across multiple files, execute commands, run tests, and inspect their results inside the repository.

That fits naturally alongside tools such as Hunk, lazygit, and zellij. One pane can run the coding agent, another can display the diff, while a third runs the application or its test suite.

The result is not necessarily a desktop without graphical applications. It is better understood as a development and system administration environment where the terminal becomes the central workspace, while graphical applications are used when they genuinely provide a better experience.

Which tool should you use for each task?

Task	CLI/TUI tool	Common GUI alternative
API testing	xh	Postman
Kubernetes	k9s	Lens
Containers	lazydocker	Docker Desktop
Image analysis	dive	Docker Desktop
Git	lazygit	GitHub Desktop / Sourcetree
Diff review	Hunk	GitHub
GitHub	gh	GitHub web interface
PostgreSQL	pgcli	pgAdmin / TablePlus
MySQL	mycli	MySQL Workbench / TablePlus
File management	yazi	Finder / Explorer
System resources	btop	Activity Monitor / Task Manager
Logs	lnav	Log dashboards
Notifications	ntfy	Slack / email
Terminal multiplexing	zellij	Multiple terminal windows
Coding agents	Agent CLI	IDE-integrated AI chat

The comparison should not be interpreted as absolute equivalence. Postman provides collaborative capabilities that xh does not attempt to reproduce. Docker Desktop does much more than display running containers. A centralised observability platform remains essential when analysing hundreds or thousands of servers.

The biggest gains appear in frequent, local, and repetitive operations.

Command-line tools also have another property that matters greatly to system administrators: a command executed manually today can become part of a shell script, CI/CD pipeline, Ansible playbook, or automated maintenance process tomorrow.

That ability to move naturally from manual operation to automation may ultimately be more valuable than saving a few seconds when opening an application.

Frequently asked questions

Do graphical applications need to be replaced with CLI tools?

No. CLI tools are particularly useful for repetitive tasks, automation, remote administration, and workflows already centred around the terminal. GUIs still have clear advantages for discovering unfamiliar systems, collaboration, and occasional operations.

What is a good CLI alternative to Postman for quick API requests?

xh provides a concise way to execute HTTP requests directly from the terminal. It does not attempt to reproduce collaborative Postman features such as shared collections and mock servers.

What terminal tools can replace parts of Docker Desktop?

lazydocker provides interactive container management, while dive specialises in analysing the layers and size of Docker and OCI images. Neither replaces every capability offered by Docker Desktop.

Which tools are particularly useful for system administrators?

k9s, lazydocker, btop, lnav, ntfy, and zellij stand out for Kubernetes operations, containers, local monitoring, log analysis, notifications, and persistent remote terminal sessions.