Most Linux users learn how to create files, copy directories, and delete unwanted data. But the filesystem has several behaviors that are not immediately obvious.

Why does a disk appear full when du cannot account for the used space? Why can a file still consume disk space after being deleted? What is the difference between a symbolic link and a hard link? And why can two paths point to the same underlying file?

Understanding these details makes you better at troubleshooting, managing storage, and avoiding mistakes that can cost you hours of work.

Here are 10 Linux filesystem techniques worth learning.

1. Understand That a Filename Is Not the File Itself

Linux filesystems commonly use inodes to store metadata about files, including ownership, permissions, timestamps, and references to the file’s data blocks.

A filename is an entry in a directory that points to an inode. This distinction explains several otherwise confusing behaviors.

Inspect a file’s inode with:

ls -i report.txt

For more detailed metadata, use:

stat report.txt

You can inspect the inode number, file size, permissions, ownership, and timestamps.

Why does this matter?

• Multiple filenames can refer to the same inode through hard links.
• Renaming a file within the same filesystem generally changes its directory entry, not the underlying file data.
• Deleting a filename does not necessarily remove the underlying data immediately.

Professional habit: When investigating file identity, metadata, or unexpected storage behavior, use stat instead of relying only on the filename.

2. Know When to Use Hard Links and Symbolic Links

Both hard links and symbolic links provide alternative ways to access files, but they work differently.

A hard link is another directory entry referring to the same inode. A symbolic link, or symlink, stores a path to another file or directory.

Create a hard link:

ln original.txt hardlink.txt

Create a symbolic link:

ln -s original.txt symlink.txt

Inspect them with:

ls -li original.txt hardlink.txt symlink.txt

The original file and hard link normally share the same inode number. The symbolic link has its own inode.

The practical differences are important:

• Hard links generally cannot cross filesystem boundaries and usually cannot be created for directories by ordinary users.
• Symbolic links can point across filesystems and can reference directories.
• A symbolic link can become broken if its target is moved or deleted.
• Removing one hard-linked filename does not remove the file’s data while another hard link remains.

When to use them: Use symlinks for convenient paths, alternate directory layouts, and references to files on other filesystems. Use hard links when you deliberately want multiple names for the same underlying file.

3. Find Out Where Your Disk Space Actually Went

One of the most common Linux troubleshooting problems is a filesystem that is nearly full even though the visible files do not appear large enough to explain the usage.

Start with:

df -h

This reports filesystem-level capacity and usage in human-readable units.

Next, inspect directory usage:

du -sh /path/to/directory

To identify the largest immediate subdirectories:

du -h --max-depth=1 /path/to/directory | sort -h

These commands answer different questions:

• df reports space usage from the filesystem's perspective.
• du estimates space used by files and directories it can traverse.

If their results differ significantly, possible explanations include deleted files that are still open by running processes, inaccessible directories, filesystem metadata, reserved blocks, or differences between allocated and apparent file sizes.

To inspect large directories without crossing into other mounted filesystems:

sudo du -xhd1 /var 2>/dev/null | sort -h

The -x option keeps du on the same filesystem, which can make the results easier to interpret.

Professional habit: Use df to identify the affected filesystem, then use du to investigate its directories. Do not assume that the largest visible file is necessarily the cause.

4. Remember That Deleting a File Does Not Always Free Its Space

This is one of the most useful filesystem behaviors to understand.

On Linux, a process can keep a file open even after its directory entry has been removed. The file’s storage remains allocated until the final open reference is closed.

This often happens with application logs.

Imagine a log file grows to several gigabytes. You delete it to free space, but df -h still shows almost the same usage.

Check for deleted files that are still open:

sudo lsof +L1

Look for entries showing deleted files with open file descriptors.

If a process is holding a deleted log file open, the usual solution is to use the application’s supported log-reopen mechanism or restart the relevant service when safe and appropriate.

Avoid blindly killing processes or writing to file descriptors you do not understand.

Why this matters: On production systems, this can explain why deleting a large log file does not recover the expected disk space.

5. Use findmnt to Understand Mounted Filesystems

Linux presents storage devices through a unified directory tree. A separate filesystem can be mounted at a directory such as /mnt/data, /home, or /var.

This means two directories that appear close together in the directory tree may reside on different filesystems.

To see what is mounted and where:

findmnt

To inspect the filesystem backing a particular path:

findmnt -T /home

You can also use:

df -hT /home

The -T option displays filesystem types alongside capacity information.

Why is this useful?

• A directory may be on a separate disk or partition.
• Moving files between filesystems is generally a copy-and-remove operation rather than a simple metadata rename.
• A filesystem mounted over an existing directory hides the directory’s previous visible contents until it is unmounted.

That last point is particularly important when troubleshooting missing files under mount points.

Professional habit: Before moving large amounts of data or investigating storage issues, determine which filesystem actually backs the path.

6. Inspect Symbolic Links Instead of Guessing Their Targets

A symbolic link may look like an ordinary file or directory in a listing, but it points somewhere else.

Display a link’s target with:

ls -l mylink

Resolve the final path with:

readlink -f mylink

For example:

ln -s /var/log/application.log app.log
readlink -f app.log

The resolved path helps establish where the link ultimately leads, provided the target can be resolved.

You can also inspect the link itself rather than the target:

stat -c '%N' mylink

This is useful when dealing with application configuration, shared directories, software installations, or paths that contain several layers of symbolic links.

One important detail: a relative symbolic link is resolved relative to the directory containing the link, not relative to the shell’s current working directory.

Professional habit: When a path behaves unexpectedly, check whether it is a symbolic link before changing or deleting anything.

7. Use mktemp Instead of Inventing Temporary Filenames

Temporary files are useful for intermediate results, downloads, scripts, and test output. But manually choosing a name such as temp.txt can cause collisions when multiple commands or users operate at the same time.

Use mktemp to create a unique temporary file:

tmpfile=$(mktemp)

For a temporary directory:

tmpdir=$(mktemp -d)

Use the resulting path in your script:

printf 'Temporary data\n' > "$tmpfile"
cat "$tmpfile"

When finished, remove the file or directory you created:

rm -f -- "$tmpfile"

For a temporary directory, ensure it contains only data that you intend to remove before running a recursive deletion.

For scripts that need cleanup even after interruption, a trap can help:

tmpfile=$(mktemp) || exit 1
trap 'rm -f -- "$tmpfile"' EXIT

This schedules cleanup when the shell exits normally or through many common error and interruption paths. It does not guarantee cleanup after every possible failure, such as a forced termination.

Professional habit: Use mktemp for temporary paths, and quote variables whenever they represent filenames.

8. Distinguish Apparent File Size From Disk Space Used

A file’s reported size is not necessarily equal to the amount of storage allocated to it.

Compare these commands:

ls -lh largefile.img
du -h largefile.img

ls -lh reports the file's apparent size. du -h reports the space allocated to the file, rounded for display.

Sparse files illustrate the difference. A sparse file can contain large regions of logical zeroes that do not require corresponding physical data blocks.

Create a test file:

truncate -s 1G sparse.img

Now inspect it:

ls -lh sparse.img
du -h sparse.img

The file appears to be 1 GB in logical size, but its allocated space may be much smaller.

Sparse files are useful for virtual disk images, database files, and applications that benefit from representing empty regions efficiently. However, not every tool, filesystem, or storage destination preserves sparseness in the same way.

Professional habit: When investigating storage, check both apparent size and allocated space. They answer different questions.

9. Use install to Create Directories and Deploy Files Cleanly

Many users create directories, copy files, and then change permissions in separate commands. The install utility can combine some of these steps.

Create a directory with specified permissions:

install -d -m 755 /tmp/myapp

Copy a file while setting its destination permissions:

install -m 644 config.conf /tmp/myapp/config.conf

Install an executable with executable permissions:

install -m 755 myscript.sh /tmp/myapp/myscript.sh

Unlike a plain cp, install is designed for deployment-style copying and can set destination permissions. It does not preserve all source metadata by default, so choose the appropriate method when ownership, timestamps, ACLs, extended attributes, or other metadata must be retained.

Also, the modes above are examples, not universal recommendations. Choose permissions appropriate for the content and the users who need access.

When to use it: install is especially handy in shell scripts, deployment procedures, and Makefiles where files need to be placed at known destinations with predictable permissions.

10. Use Atomic File Replacement to Avoid Partially Written Configuration Files

Suppose a script updates a configuration file by writing directly to it:

generate_config > config.conf

If the generating command fails after writing only part of the output, the original configuration may already have been truncated or replaced with incomplete content.

A safer pattern is to write to a temporary file first, verify that generation succeeded, and then rename it into place.

tmpfile=$(mktemp ./config.conf.XXXXXX) || exit 1

if generate_config > "$tmpfile"; then
    mv -f -- "$tmpfile" config.conf
else
    rm -f -- "$tmpfile"
    exit 1
fi

Because the temporary file is created in the same directory, the final rename is normally atomic on a local filesystem that supports standard rename semantics. Readers will see either the old file or the new file, rather than a partially written intermediate version.

There are important caveats:

• The generating command must report failures correctly.
• The destination directory must be writable.
• Atomic visibility does not by itself guarantee that data has been durably written to physical storage after a sudden power loss.
• Replacing a file this way can change ownership, permissions, and other metadata unless you deliberately preserve or set them.

Professional habit: For configuration files and other critical outputs, generate first, validate second, and replace the destination only after success.

Final Thoughts

Linux filesystem expertise is not just about memorizing ls, cp, mv, and rm. It is about understanding how names, inodes, storage allocation, mounts, and file descriptors interact.

The most valuable habits from this list are:

• Use stat when you need to understand file metadata.
• Know the difference between hard links and symbolic links.
• Use df and du together to investigate storage.
• Check for deleted files that remain open.
• Inspect mount points before moving or troubleshooting data.
• Use mktemp for safe temporary paths.
• Understand apparent size versus allocated disk space.
• Replace critical files carefully rather than overwriting them prematurely.

These details may seem small, but they make a real difference when debugging storage problems, writing reliable scripts, or maintaining Linux systems.

The goal is not to know more commands. It is to understand what the filesystem is actually doing.

If you work with Linux servers, you probably use SSH regularly.

You type something like:

ssh user@192.168.1.100

You enter your credentials, connect to the machine, and start working.

That is fine for basic remote access. But SSH can do much more than open a remote terminal.

You can connect to multiple servers using short aliases, execute commands without opening an interactive session, transfer files securely, forward ports, reuse existing connections, and troubleshoot network problems without installing additional software.

The difference is not about memorizing more commands. It is about learning how to configure SSH so that routine work requires fewer steps.

Here are 10 SSH techniques worth learning if you work with remote Linux machines.

1. Stop Typing Long SSH Commands: Use Host Aliases

Suppose you regularly connect to three servers:

ssh raja@192.168.1.100
ssh raja@192.168.1.101
ssh admin@10.0.0.25

You must remember each address and username. If a server requires a particular key or port, the command becomes even longer.

SSH configuration solves this problem.

Open your SSH configuration file:

nano ~/.ssh/config

Add entries like these:

Host workserver
    HostName 192.168.1.100
    User raja

Host testserver
    HostName 192.168.1.101
    User raja

Host production
    HostName 10.0.0.25
    User admin
    Port 2222

Now connect using:

ssh workserver

Or:

ssh testserver

Or:

ssh production

SSH reads the configuration and fills in the appropriate connection details.

You can also specify a private key:

Host workserver
    HostName 192.168.1.100
    User raja
    IdentityFile ~/.ssh/work_key
    IdentitiesOnly yes

This is particularly useful when managing several servers with different accounts and authentication requirements.

Power-user takeaway: Put recurring connection settings in ~/.ssh/config instead of repeatedly typing them at the command line.

The IP addresses and usernames above are examples. Replace them with your actual server details.

2. Use SSH Keys Instead of Repeated Password Authentication

If you connect to the same server frequently, key-based authentication can simplify the login process and provide strong security when configured correctly.

First, generate an SSH key pair on your local machine:

ssh-keygen -t ed25519

Follow the prompts. A passphrase is recommended to protect the private key if the file is copied or stolen.

This creates two files by default:

~/.ssh/id_ed25519
~/.ssh/id_ed25519.pub

The first is your private key. Keep it private.

The second is your public key. It can be installed on the server.

On a system that supports it, run:

ssh-copy-id raja@192.168.1.100

Then connect:

ssh raja@192.168.1.100

After successful setup, SSH can authenticate using the key instead of requiring the account password for every connection. If your private key has a passphrase, you may still need to unlock it unless an agent has already done so.

If ssh-copy-id is unavailable, you can install the public key manually in the remote account's ~/.ssh/authorized_keys file.

A security detail worth remembering

Never copy your private key to the server just to enable authentication.

The public key belongs on the remote machine. The private key should remain under your control.

Key-based authentication also does not automatically disable password authentication on the server. That is a separate server-side security decision.

3. Use ssh-agent to Avoid Repeatedly Entering Your Key Passphrase

You have generated an SSH key and protected it with a passphrase.

That’s good security, but repeatedly entering the passphrase during a long work session can become tedious.

An SSH agent can hold an unlocked key for you.

Start an agent in environments where one is not already running:

eval "$(ssh-agent -s)"

Add your key:

ssh-add ~/.ssh/id_ed25519

Enter the passphrase when prompted.

You can inspect the identities currently available to the agent:

ssh-add -l

Now SSH can use the loaded key for subsequent connections supported by that agent.

Modern desktop environments often start and manage an agent automatically, so you may not need to run these commands manually.

Why this matters

You retain the protection of an encrypted private key without having to unlock it for every connection.

For shared or untrusted machines, be careful about how long keys remain loaded and which processes can access the agent.

4. Execute Commands on a Remote Server Without Opening a Shell

Sometimes you don’t need an interactive terminal on the remote machine.

You simply need information or want to perform one operation.

For example:

ssh workserver "uptime"

This connects to the remote host, executes uptime, and returns the output.

Check disk space:

ssh workserver "df -h"

Check memory:

ssh workserver "free -h"

Check whether a particular service is active:

ssh workserver "systemctl is-active nginx"

The remote account must have permission to run the requested command.

You can also execute several commands:

ssh workserver "cd /var/log && ls -lh"

The commands inside the quotes are interpreted by the remote shell.

Run the same check on multiple servers

If your SSH configuration contains several host aliases:

for host in workserver testserver; do
    echo "Checking $host"
    ssh "$host" "uptime"
done

This is a simple way to collect information from several machines.

For larger deployments, monitoring systems or configuration-management tools may be more appropriate. But for a small number of servers, SSH loops are often sufficient.

5. Keep Long-Running Work Alive With tmux

You SSH into a server, start a lengthy task, and then your internet connection drops.

What happens?

If the task is running directly in your interactive shell, the disconnection may cause the session and its processes to terminate. The exact behavior depends on the shell, process, and session configuration.

A useful solution is tmux.

On the remote server, start a session:

tmux new -s work

Run your command inside it:

./long_running_task.sh

To detach from the session while leaving it running, press:

Ctrl+B, then D

You return to the remote shell without closing the tmux session.

Later, reconnect to the server:

ssh workserver

List available sessions:

tmux ls

Reattach:

tmux attach -t work

Your terminal session, including its running foreground program, remains available.

Important distinction

tmux is not an SSH option. It is a terminal multiplexer that runs on the remote machine.

SSH provides the connection. tmux preserves the terminal session independently of that connection.

If the remote machine reboots or the process crashes, tmux cannot preserve the lost process.

6. Transfer Files Securely With scp

SSH is not limited to interactive sessions. You can use it to transfer files between computers.

To copy a local file to a remote server:

scp report.txt workserver:/home/raja/

To copy a remote file to your local machine:

scp workserver:/home/raja/report.txt .

To copy a directory recursively:

scp -r project/ workserver:/home/raja/

You can also specify a non-default port:

scp -P 2222 report.txt production:/home/admin/

Notice that scp uses uppercase -P for the port option.

When should you use scp?

Use it for straightforward file transfers.

If you regularly synchronize large directories, preserve metadata, or transfer only changed files, rsync may be more suitable.

For example:

rsync -avh --progress project/ workserver:/home/raja/project/

Both tools can use SSH for secure transport.

One practical distinction is that scp copies files, while rsync is designed to synchronize files and directory trees efficiently.

7. Forward a Remote Port to Your Local Machine

This is one of SSH’s most useful features for developers and administrators.

Suppose a web application is running on a remote server and listening on port 3000.

The service is not exposed directly to the public internet, but you want to access it from your own browser.

You can create a local port forward:

ssh -L 8080:localhost:3000 workserver

Leave this SSH session open.

Then open the following address on your local machine:

http://localhost:8080

The connection follows this path:

Your browser
     |
     | localhost:8080
     v
Local SSH listener
     |
     | encrypted SSH connection
     v
Remote server
     |
     | localhost:3000
     v
Web application

The important detail is that localhost:3000 in this command refers to the remote server's network environment, not your local computer.

This technique is called local port forwarding.

When is this useful?

• Accessing a development server on a remote machine
• Inspecting an internal web dashboard
• Connecting to a database that should not be publicly exposed
• Testing services bound to the remote loopback interface

Only forward services you are authorized to access. Keep the SSH connection protected, and avoid exposing the local forwarded port to other machines unless that is intentional.

8. Reuse SSH Connections to Reduce Repeated Connection Overhead

If you repeatedly run remote commands against the same server, SSH may spend time establishing a new connection for each command.

OpenSSH supports connection multiplexing, which allows multiple sessions to reuse an existing authenticated connection.

Add the following to ~/.ssh/config:

Host workserver
    HostName 192.168.1.100
    User raja
    ControlMaster auto
    ControlPath ~/.ssh/cm-%C
    ControlPersist 10m

Now run:

ssh workserver

Additional SSH connections to the same configured host can reuse the master connection while it remains available.

The settings mean:

• ControlMaster auto: Reuse or establish a master connection when appropriate.
• ControlPath: Specify where the local control socket is stored.
• ControlPersist 10m: Keep the master connection available for up to ten minutes after its original session closes, subject to the connection's state.

This can reduce repeated connection setup overhead, especially when running scripts that issue many SSH commands.

A security consideration

The control socket is sensitive because it can allow access to an authenticated connection. Keep it in a directory with appropriate permissions, and avoid placing it in a shared location.

You can close a master connection explicitly:

ssh -O exit workserver

This works when a corresponding master connection is active and the configuration matches.

9. Use SSH Configuration to Handle Different Ports and Connection Options

Some servers listen on the default SSH port 22. Others use a different port or require a jump host.

You can specify a port directly:

ssh -p 2222 raja@192.168.1.100

Remember that SSH uses lowercase -p for the connection port.

For recurring connections, store the setting:

Host production
    HostName 10.0.0.25
    User admin
    Port 2222

Then:

ssh production

What if the server is reachable only through another machine?

OpenSSH supports jump hosts.

For example:

Host bastion
    HostName bastion.example.com
    User raja

Host internal
    HostName 10.0.0.25
    User admin
    ProxyJump bastion

Now:

ssh internal

SSH connects through the configured bastion host to reach the internal machine.

This is useful in environments where servers are isolated from direct public access.

The jump host must itself be reachable, and the network and SSH policies must permit the onward connection.

10. Debug SSH Connections Instead of Guessing

SSH failures can come from several places:

• Incorrect usernames or hostnames
• Network connectivity problems
• Wrong ports
• Missing or incorrect private keys
• Server-side authentication settings
• Host key verification failures
• File permission problems involving SSH keys

Instead of repeatedly changing settings, increase the verbosity of the SSH client.

Run:

ssh -v workserver

For more diagnostic detail:

ssh -vv workserver

And, when needed:

ssh -vvv workserver

These options reveal more information about connection setup, key selection, authentication attempts, and protocol negotiation.

You can also test whether a TCP connection can be established to a particular SSH port:

nc -vz 192.168.1.100 22

This requires nc (netcat) to be installed. It tests basic reachability to the port, not whether SSH authentication will succeed.

Check host key warnings carefully

If SSH reports that a server’s host key has changed, do not blindly disable host key checking or delete the old key.

The change may be legitimate, such as after a server rebuild, but it can also indicate a security problem.

Verify the new host key through a trusted channel before accepting it.

Good troubleshooting begins with evidence, not with disabling security checks.

The Bigger Picture: Turn SSH Into a Workflow

These techniques become especially useful when combined.

For example, you could configure a host alias, connect using a key, run a remote command, and capture its output:

ssh workserver "df -h" > disk_report.txt

Or use SSH with a remote session that survives a dropped connection:

SSH
 |
 v
Remote Linux server
 |
 v
tmux session
 |
 v
Long-running task

Or access a private application through a local tunnel:

Browser
   |
   v
localhost:8080
   |
   v
SSH tunnel
   |
   v
Remote localhost:3000

The goal is not to use every SSH feature. It is to recognize which feature solves the problem in front of you.

Final Thoughts

SSH is much more than a command for opening a remote terminal.

With a well-configured SSH client, you can simplify server access, automate remote checks, transfer files, maintain long-running terminal sessions, reach private services, and diagnose connection failures.

Start with these habits:

• Use ~/.ssh/config for recurring hosts.
• Prefer key-based authentication with a protected private key.
• Use ssh-agent when appropriate.
• Execute remote commands directly when an interactive shell isn’t needed.
• Use tmux for terminal sessions that should survive disconnections.
• Choose scp or rsync based on your transfer needs.
• Use port forwarding for authorized access to private services.
• Consider connection multiplexing for repeated SSH operations.
• Configure jump hosts when network architecture requires them.
• Use verbose diagnostics instead of disabling security protections.

The real advantage comes from reducing repetitive work while maintaining control over access and security.

The next time you type ssh user@server, consider whether you could make that connection simpler, more secure, or easier to troubleshoot.

That’s how you turn SSH from a basic remote-login tool into a practical part of your everyday Linux workflow.

In the second article, 10 Linux Techniques That Separate Beginners From Power Users, I moved beyond individual commands to explain how pipes, redirection, command substitution, conditional execution, and background processes make the command line more powerful.

In the third article, 10 Bash Time-Saver One-Liners That Turn Naive Users into Pro Users, I demonstrated how Bash can automate repetitive tasks involving files, directories, filenames, and text.

Now, it’s time to focus on a specific skill that connects all three topics: text processing.

Imagine you have a server log containing thousands of lines, a configuration file with hundreds of settings, or a text file containing records you need to analyze.

You want to find specific entries, extract a few columns, replace text, remove duplicates, or calculate a total.

Opening the file and processing everything manually is rarely the most efficient approach.

Linux provides tools that let you perform these operations directly from the terminal, often with just one command.

In this article, we’ll explore seven useful text-processing tools:

• grep
• cut
• awk
• sed
• sort
• uniq
• wc

Let’s get started.

1. grep: Find Exactly What You're Looking For

You’ve probably used grep to search for text. But searching becomes much more useful when you understand how to apply it to real-world problems.

Imagine a file named server.log containing:

2026-10-10 09:12:03 INFO Server started
2026-10-10 09:12:08 ERROR Connection failed
2026-10-10 09:12:12 INFO Request received
2026-10-10 09:12:19 ERROR Authentication failed
2026-10-10 09:12:25 WARNING Disk usage high

To find errors:

grep "ERROR" server.log

To search without worrying about uppercase or lowercase:

grep -i "error" server.log

To display line numbers:

grep -n "ERROR" server.log

To find lines that do not contain a particular pattern:

grep -v "INFO" server.log

You can also search using regular expressions.

For example, to find lines beginning with a date:

grep '^[0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}' server.log

The ^ anchors the pattern to the beginning of a line.

When to use it: Searching logs, locating configuration settings, filtering records, and finding patterns in large text files.

2. cut: Extract Only the Columns You Need

Suppose you have a comma-separated file named employees.csv:

name,department,salary
Alice,Engineering,75000
Bob,Marketing,62000
Charlie,Engineering,81000
Diana,Finance,70000

You want only the employee names.

Use:

cut -d',' -f1 employees.csv

Here:

• -d',' specifies the comma delimiter.
• -f1 selects the first field.

To extract names and salaries:

cut -d',' -f1,3 employees.csv

To extract the second field:

cut -d',' -f2 employees.csv

You can also extract character positions rather than delimited fields:

cut -c1-10 file.txt

This displays the first ten characters of each line.

An important limitation

cut works well with simple, consistently delimited text. It is not a full CSV parser.

For example, consider:

name,description,salary
Alice,"Engineering, Research",75000

Because the description contains a comma inside quotation marks, cut -d',' will not correctly interpret the CSV fields.

For complex CSV files, use a proper CSV parser.

When to use it: Extracting fields from simple CSV files, tab-separated tables, and consistently structured text.

3. awk: Filter Records, Extract Fields, and Perform Calculations

If you learn only one tool specifically for structured text processing, consider learning awk.

It treats each line as a record and, by default, splits that line into whitespace-separated fields.

Consider this file:

Alice Engineering 75000
Bob Marketing 62000
Charlie Engineering 81000
Diana Finance 70000

Save it as employees.txt.

To print only the first column:

awk '{print $1}' employees.txt

Output:

Alice
Bob
Charlie
Diana

To print names and salaries:

awk '{print $1, $3}' employees.txt

Now suppose you want only employees earning more than 70,000:

awk '$3 > 70000' employees.txt

You can calculate the average salary:

awk '{sum += $3; count++} END {if (count) print sum/count}' employees.txt

This works in two stages:

1. For every line, add the third field to sum and increment count.
2. After processing the file, calculate the average.

You can also calculate the total:

awk '{sum += $3} END {print sum}' employees.txt

Why awk matters

You can use it to filter records, extract columns, count entries, calculate totals, and generate summaries.

For small, structured-text tasks, it can eliminate the need to write a separate script.

When to use it: Working with tables, processing delimited records, filtering rows by conditions, and performing calculations directly in the terminal.

4. sed: Replace Text Without Opening a File

Suppose a configuration file contains:

server=old-server
port=8080
environment=production

You want to replace old-server with new-server.

Use:

sed 's/old-server/new-server/g' config.txt

This prints the modified text to the terminal. It does not change the original file.

The substitution syntax is:

s/old-text/new-text/g

The final g means that all non-overlapping matches on each line are replaced, rather than only the first match.

To modify the file directly:

sed -i.bak 's/old-server/new-server/g' config.txt

On GNU/Linux, this changes the file and creates a backup named config.txt.bak.

To remove blank lines from the displayed output:

sed '/^[[:space:]]*$/d' config.txt

To print only lines 10 through 20:

sed -n '10,20p' config.txt

A word of caution

Commands using sed -i modify files directly. Test the transformation on a copy or create a backup before applying it to important configuration files.

When to use it: Replacing text, removing unwanted lines, and applying simple transformations to one or more text files.

5. sort: Put Records in the Order You Need

Sorting is useful when you want to organize data, identify repeated entries, or prepare records for further processing.

Suppose numbers.txt contains:

100
20
9
50

Run:

sort numbers.txt

The default is lexicographic sorting, not numerical sorting. Therefore, the result may not be the numerical order you expect.

For numerical sorting:

sort -n numbers.txt

Output:

9
20
50
100

For reverse numerical order:

sort -nr numbers.txt

For a tab-separated file, you can sort by the second column:

sort -t $'\t' -k2,2 data.tsv

Here:

• -t specifies the delimiter.
• -k2,2 selects the second field as the sort key.

To sort that field numerically in descending order:

sort -t $'\t' -k2,2nr data.tsv

When to use it: Ordering records, sorting by columns, preparing data for duplicate counting, and identifying the largest or smallest values.

6. uniq: Identify Repeated Entries

Suppose you have a file containing:

apple
banana
apple
orange
banana
apple

You might expect:

uniq fruits.txt

to remove every duplicate.

It doesn’t.

uniq compares adjacent lines only. In the example above, the repeated entries are separated, so they will not all be collapsed.

To identify unique entries regardless of their original order, sort first:

sort fruits.txt | uniq

To count occurrences:

sort fruits.txt | uniq -c

To display the most frequent entries first:

sort fruits.txt | uniq -c | sort -nr

The result will resemble:

3 apple
2 banana
1 orange

This is a useful pattern to remember:

sort file.txt | uniq -c | sort -nr

It sorts the input, counts adjacent identical lines, and then sorts the counts numerically in descending order.

When to use it: Finding repeated values, counting categories, and identifying frequent entries in logs or text files.

7. wc: Count Lines, Words, and Characters

Sometimes you don’t need to inspect a file’s contents. You just need to know how much data it contains.

That’s where wc comes in.

Count lines:

wc -l server.log

Count words:

wc -w document.txt

Count bytes:

wc -c document.txt

Count characters:

wc -m document.txt

These last two are different: a multibyte character can occupy more than one byte.

You can also count the number of lines matching a pattern:

grep -c "ERROR" server.log

Or count files in the current directory using Bash filename expansion:

printf '%s\n' * | wc -l

This last example counts the entries matched by *, including directories and hidden-file exclusions inherent to the default expansion. It is not a recursive file count.

For a count of regular files recursively, use:

find . -type f | wc -l

When to use it: Counting lines, measuring text, estimating the size of a dataset, and checking the output of a processing step.

Put the Commands Together

Individual commands are useful. Combining them lets you solve more interesting problems.

Imagine you have a log file and want to identify the ten most frequent error messages.

You could run:

grep "ERROR" server.log | sort | uniq -c | sort -nr | head -n 10

Let’s break that down:

CommandPurposegrep "ERROR"Select lines containing ERRORsortPlace identical lines next to one anotheruniq -cCount adjacent identical linessort -nrSort counts in descending numerical orderhead -n 10Display the first ten results

This is a compact workflow, but it is important to understand what it actually counts.

It counts identical complete log lines, not necessarily distinct error types. If each line contains a different timestamp, the same underlying error may appear as multiple separate entries.

If you want to group messages by error category, you first need to extract or normalize the relevant part of each line.

That is where tools such as awk and sed become useful.

The broader idea is simple:

Search the data, extract the relevant information, transform it, organize it, and summarize the result.

You can apply this approach to log files, configuration files, exported tables, and many other kinds of structured text.

If you have been following this series, you have already seen two sides of working efficiently in Linux.

The first article, 10 Linux Commands Every Power User Should Know, focused on individual commands such as grep, find, ssh, rsync, tail, df, du, ps, kill, and chmod.

The second article, 10 Linux Techniques That Separate Beginners From Power Users , moved beyond individual commands and covered pipes, redirection, stdin/stdout/stderr, command substitution, conditional execution, background jobs, tee, xargs, and awk.

Instead, let’s look at something more practical:

Small Bash one-liners that eliminate repetitive work.

These aren’t commands you need to memorize for an exam. They are shortcuts you can reach for when you encounter an everyday problem in the terminal.

1. Create Multiple Files or Directories With Brace Expansion

Suppose you need to create three directories:

mkdir reports logs backups

That’s fine.

But Bash can generate the names for you:

mkdir {reports,logs,backups}

You can also generate sequences:

mkdir project_{01..05}

This creates:

project_01
project_02
project_03
project_04
project_05

The same technique works with files:

touch file_{1..10}.txt

You get:

file_1.txt
file_2.txt
...
file_10.txt

You can even combine expansions:

touch report_{2024..2026}_{jan,apr,jul,oct}.txt

That’s a lot of filenames generated from a single command.

Why it saves time

Whenever you notice yourself typing a repetitive sequence of filenames, ask:

Can Bash generate this pattern for me?

Often, the answer is yes.

2. Rename Files Using Bash Parameter Expansion

Suppose you have:

report_old.txt
data_old.txt
summary_old.txt

and want to replace _old with _new.

Instead of manually renaming each file:

for f in *_old.txt; do mv "$f" "${f/_old/_new}"; done

The important part is:

${f/_old/_new}

Bash takes the filename stored in $f and replaces _old with _new.

The result:

report_new.txt
data_new.txt
summary_new.txt

You can also remove part of a filename:

for f in *.backup; do mv "$f" "${f%.backup}"; done

For example:

report.txt.backup

becomes:

report.txt

This is extremely useful when dealing with batches of consistently named files.

3. Extract the Filename or Directory From a Path

Suppose you have:

path="/home/user/projects/report.txt"

You can extract the filename:

basename "$path"

Result:

report.txt

Or extract the directory:

dirname "$path"

Result:

/home/user/projects

You can combine them:

echo "$(basename "$path") is located in $(dirname "$path")"

This becomes especially useful in shell scripts where you don’t know the path in advance.

4. Find the Absolute Path of a File

Relative paths can become confusing.

For example:

./data/results.txt

What is the actual location?

Use:

realpath ./data/results.txt

You might get:

/home/raja/project/data/results.txt

This is useful when:

• writing scripts
• passing files between programs
• debugging path problems
• working with symbolic links
• recording reproducible file locations

A related command is:

readlink -f ./data/results.txt

On systems where it is supported, this resolves the path to its canonical absolute location.

5. Replace Text Directly Inside Multiple Files

Suppose several configuration files contain:

server=old-server

and you need:

server=new-server

You can use:

sed -i 's/server=old-server/server=new-server/g' *.conf

The -i option modifies the files directly.

Before using it on important files, test the substitution without -i:

sed 's/server=old-server/server=new-server/g' example.conf

If the output looks correct, then use -i.

For an additional safety measure, some systems support:

sed -i.bak 's/server=old-server/server=new-server/g' *.conf

This creates backup copies with .bak.

Why this saves time

Instead of opening ten configuration files, editing each one, saving them, and repeating the process, you can perform the same transformation across the entire set.

6. Quickly Compare Two Files

You don’t always need to open two files manually to see what’s different.

Use:

diff file1.txt file2.txt

For a more readable side-by-side comparison:

diff -y file1.txt file2.txt

If you’re comparing directories:

diff -rq directory1 directory2

This tells you which files differ without dumping their entire contents.

For example:

Files directory1/config.txt and directory2/config.txt differ
Only in directory1: old.log
Only in directory2: new.log

This is particularly useful when troubleshooting configuration changes or checking whether two directory trees are actually identical.

7. Run a Command Repeatedly With watch

Sometimes you don’t need a complicated monitoring system.

You simply want to run the same command every few seconds.

For example:

watch -n 2 'date'

The command runs every two seconds.

You can use it with system information:

watch -n 2 'free -h'

Or monitor a directory:

watch -n 1 'ls -lh'

You can even monitor a particular value:

watch -n 2 'df -h /'

Instead of repeatedly typing the same command and clearing your terminal, watch turns it into a simple live display.

Press:

Ctrl + C

to stop it.

8. Find and Process Only the Files You Want

The previous article introduced find, but there is more to it than simply locating files.

For example, suppose you want to list files modified within the last day:

find . -type f -mtime -1

You can combine file properties with an action.

For example, find empty files:

find . -type f -empty

Find files larger than 500 MB:

find . -type f -size +500M

Find files with a particular extension and print their sizes:

find . -type f -name "*.log" -exec ls -lh {} \;

The important concept here is:

find
  ↓
identify exactly what you want
  ↓
perform an action

This is much safer than applying an operation blindly to an entire directory.

9. Use Bash Defaults to Make Scripts More Robust

This is one of the most useful Bash features that many beginners overlook.

Suppose your script expects a variable:

echo "$NAME"

What happens if $NAME hasn’t been defined?

You can provide a default:

echo "${NAME:-Unknown}"

If NAME exists, its value is used.

If it doesn’t, Bash uses:

Unknown

You can also set a default:

NAME="${NAME:-Raja}"

Now NAME becomes Raja if it wasn't already defined.

Another useful form is:

echo "${FILE:?FILE variable is required}"

If FILE isn't defined, Bash produces an error instead of silently continuing.

This is especially useful in scripts where missing variables could cause incorrect results.

10. Process a Batch of Files With a Bash Loop

One of the most useful things you can do with Bash is turn a repetitive manual task into a one-liner.

Suppose you have:

file1.txt
file2.txt
file3.txt

and want to create a compressed version of each file.

You could write:

for f in *.txt; do gzip "$f"; done

That’s one line, but it represents a complete workflow:

Find matching files
       ↓
Take one filename
       ↓
Run the command
       ↓
Move to the next file
       ↓
Repeat

You can substitute almost any operation.

For example:

for f in *.log; do echo "$f"; done

Or:

for f in *.txt; do cp "$f" "backup_$f"; done

Or:

for f in *.jpg; do mv "$f" "${f%.jpg}.jpeg"; done

This is where Bash starts becoming an automation language rather than simply a place to type commands.

In my previous article, “10 Linux Commands Every Power User Should Know,” I covered practical commands such as grep, find, history, curl, ssh, rsync, tail, df, du, ps, kill, and chmod.

But there is a limit to learning commands one by one.

A Linux user who knows 50 commands but runs them independently can still be less effective than someone who knows 15 commands and understands how to combine them.

The real power of the Linux command line comes from techniques such as pipes, redirection, command substitution, background execution, and text processing.

So, in this article, we move from:

“Do you know the command?”

to:

“Do you know how to use the command?”

Here are 10 Linux techniques that are worth mastering.

1. Pipes |: Make One Command Feed Another

The pipe is probably the most important concept to understand if you want to become comfortable with Linux.

A pipe takes the standard output of one command and sends it as standard input to another command.

For example:

cat access.log | grep "404"

The output from cat becomes the input for grep.

But you don’t actually need cat here. A better version is:

grep "404" access.log

The real power appears when you chain several operations:

grep "404" access.log | sort | uniq -c

Now the workflow is:

access.log
    ↓
grep
    ↓
sort
    ↓
uniq -c
    ↓
counted results

You can continue:

grep "404" access.log | sort | uniq -c | sort -nr

Now you’re asking Linux to:

1. Find lines containing 404
2. Sort them
3. Count identical lines
4. Sort the counts numerically in reverse order

This is one of the fundamental ideas behind the Unix philosophy:

Build small tools that do one thing well, then combine them.

2. Redirection: Control Where Your Output Goes

Normally, a command prints its output to your terminal.

But you can redirect that output to a file.

>

ls -lah > files.txt

Instead of displaying the result, Linux writes it to files.txt.

Be careful:

> files.txt

overwrites the existing contents.

>>

If you want to append instead:

date >> activity.log

This adds the date to the end of the file without replacing what is already there.

So:

>   overwrite
>>  append

This becomes particularly useful when building scripts and keeping logs.

For example:

echo "Pipeline started" > pipeline.log
echo "Step 1 completed" >> pipeline.log
echo "Step 2 completed" >> pipeline.log

3. Understand stdin, stdout, and stderr

This is one of those Linux concepts that seems complicated until you see the model.

Every normal Linux process has three standard streams:

stdin   → 0 → input
stdout  → 1 → normal output
stderr  → 2 → error output

Think of them as three channels.

By default:

Keyboard ──→ stdin ──→ command ──→ stdout ──→ terminal
                              \
                               └── stderr ──→ terminal

You can redirect them separately.

Redirect standard output

command > output.txt

Redirect errors

command 2> errors.txt

Redirect both

command > output.txt 2>&1

This is extremely useful when running long analyses.

For example:

./pipeline.sh > pipeline.log 2>&1

Now both normal output and error messages are captured in the same log.

This becomes even more useful when combined with background execution.

4. Command Substitution: Use the Output of One Command Inside Another

Suppose you want to create a directory named after today’s date.

You could use:

mkdir 2026-09-17

But Linux can generate the date dynamically:

mkdir "$(date +%Y-%m-%d)"

The part inside:

$(...)

is executed first.

Its output is then inserted into the surrounding command.

For example:

echo "Today is $(date)"

might produce:

Today is Thu Sep 17 10:30:00 IST 2026

Another example:

echo "There are $(wc -l < file.txt) lines"

This is particularly useful in shell scripts because commands can become dynamic rather than hard-coded.

5. && vs ;: Control What Happens Next

These two operators look similar but behave differently.

Semicolon ;

command1 ; command2

means:

Run command2 after command1, regardless of whether command1 succeeded.

For example:

mkdir results ; echo "Done"

Even if creating the directory fails, the second command is still attempted.

&&

command1 && command2

means:

Run command2 only if command1 succeeds.

For example:

mkdir results && echo "Directory created"

This is much safer when commands depend on each other.

You can chain several operations:

mkdir results && cd results && touch output.txt

The workflow stops when one command fails.

A useful mental model is:

;   → do this, then do that

&&  → do this successfully, then do that

6. Background Processes: Don’t Tie Up Your Terminal

Suppose you start a long-running command:

./long_pipeline.sh

Your terminal is now occupied until the process finishes.

You can place it in the background with:

./long_pipeline.sh &

The & tells the shell to run the command asynchronously.

You can inspect background jobs with:

jobs

And bring one back to the foreground with:

fg

Or send it back to the background with:

bg

For a job that needs to keep running after you disconnect from the terminal, nohup is another useful technique:

nohup ./long_pipeline.sh > pipeline.log 2>&1 &

This combines several techniques from this article:

• nohup → protects the process from a hangup
• > → redirects output
• 2>&1 → redirects errors to the same log
• & → runs the process in the background

That’s exactly what I mean by combining techniques rather than memorizing commands.

7. tee: See the Output and Save It at the Same Time

Sometimes you want output to appear on your screen and be saved to a file.

That’s where tee is useful.

ls -lah | tee directory_listing.txt

The output is displayed in the terminal while simultaneously being written to:

directory_listing.txt

You can also append:

command | tee -a log.txt

This is useful for monitoring scripts and pipelines where you don’t want to choose between seeing output and recording it.

For example:

./pipeline.sh 2>&1 | tee pipeline.log

Now you can watch the pipeline while keeping a permanent record.

8. xargs: Turn Output Into Arguments

xargs is one of the commands that initially looks strange but becomes extremely powerful.

Suppose you have:

sample1.txt
sample2.txt
sample3.txt

You can do:

cat files.txt | xargs rm

Conceptually:

files.txt
   ↓
xargs
   ↓
rm sample1.txt sample2.txt sample3.txt

xargs takes input and constructs commands from it.

A more useful example:

find . -name "*.log" -print0 | xargs -0 grep "ERROR"

This searches the matching log files for ERROR.

The -0 combination is important when filenames may contain spaces or other special characters.

xargs is particularly useful when the output of one command needs to become the arguments of another command.

9. Use awk for Structured Text Instead of Manually Editing Files

Linux becomes extremely powerful when you start treating text files as data.

Suppose you have:

sample   reads    status
A01      1200000  PASS
A02       450000  FAIL
A03       980000  PASS

You can extract the first column with:

awk '{print $1}' results.txt

Or select rows:

awk '$3 == "PASS"' results.txt

Or print specific columns:

awk '{print $1, $2}' results.txt

You can even perform calculations:

awk '{sum += $2} END {print sum}' results.txt

This is why awk is so useful for tabular data.

You don’t necessarily need Python or R for every small text-processing task.

Sometimes:

awk

is enough.

10. Build Commands Incrementally Instead of Writing One Giant Command

This is less a command and more a habit.

Suppose your final command is:

grep -v '^#' results.tsv | awk '$3=="PASS" {print $1,$2}' | sort -k2,2nr | head

Don’t write it all at once.

Build it.

Start:

grep -v '^#' results.tsv

Then:

grep -v '^#' results.tsv | awk '$3=="PASS"'

Then:

grep -v '^#' results.tsv | awk '$3=="PASS" {print $1,$2}'

Then:

grep -v '^#' results.tsv | awk '$3=="PASS" {print $1,$2}' | sort -k2,2nr

Finally:

grep -v '^#' results.tsv | awk '$3=="PASS" {print $1,$2}' | sort -k2,2nr | head

At each stage, inspect the output.

This makes debugging much easier.

A common beginner mistake is trying to construct a complicated one-liner immediately, getting an unexpected result, and then having no idea which part failed.

Power users don’t necessarily write complicated commands from the beginning. They know how to decompose problems into simple commands and then compose them.

The Bigger Picture

The techniques above are not isolated tricks.

They fit together.

Consider this command:

grep "ERROR" application.log | sort | uniq -c | sort -nr | tee error_summary.txt

You’ve just used:

• grep for searching
• | for piping
• sort for ordering
• uniq -c for counting
• sort -nr for numerical sorting
• tee for displaying and saving output

Or consider:

nohup ./analysis.sh > analysis.log 2>&1 &

This uses:

• background execution
• output redirection
• error redirection
• nohup

The individual pieces aren’t particularly complicated.

The important skill is knowing how they interact.

A Useful Mental Model

When working at the Linux command line, start thinking in terms of:

INPUT
  ↓
SEARCH
  ↓
FILTER
  ↓
TRANSFORM
  ↓
SORT / COUNT
  ↓
SAVE

For example:

grep "PASS" results.tsv \
    | awk '{print $1,$3}' \
    | sort \
    | uniq -c \
    | tee summary.txt

You don’t need one giant program to perform every operation.

You can build a workflow from small, predictable components.

That’s one of the fundamental strengths of the Unix/Linux command line

They type a command, press Enter, and hope for the best.

Power users work differently.

They know how to find information quickly, monitor their system, inspect logs, manage processes, and combine simple commands into powerful workflows.

The good news? You don’t need to memorize hundreds of commands.

Here are 10 Linux commands that can dramatically improve the way you work in the terminal.

1. grep — Find What You Actually Need

grep searches for specific text inside files.

Imagine you have a massive log file with thousands of lines. Instead of manually scrolling through it, you can search for exactly what you need.

grep "ERROR" application.log

This will display every line containing ERROR.

Useful options

Ignore uppercase and lowercase differences:

grep -i "error" application.log

Search recursively through directories:

grep -r "password" .

Show line numbers:

grep -n "ERROR" application.log

Power-user example

grep -rni "database connection failed" /var/log/

This searches recursively, ignores case differences, and shows line numbers.

Once you start working with logs and large codebases, grep becomes indispensable.

2. find — Locate Files Like a Pro

Can’t remember where a file is?

Use find.

Search for all Python files:

find . -name "*.py"

Search for a specific file:

find /home -name "config.json"

Find files larger than 1 GB:

find / -type f -size +1G

Find files modified in the last seven days:

find . -mtime -7

Power-user example

Find all .log files and delete them:

find . -name "*.log" -delete

⚠️ Be careful with destructive commands.

A safer approach is to first run:

find . -name "*.log"

Verify the results before adding -delete.

That simple habit can save you from deleting the wrong files.

3. history — Stop Typing the Same Commands Again

Your terminal remembers the commands you’ve previously executed.

View your command history:

history

Search for a previous command:

history | grep docker

Repeat the last command:

!!

Run a specific command from history:

!245

For example, if command number 245 was a long rsync command, you don't need to type it again.

Power-user tip

Use reverse search:

Press:

Ctrl + R

Then start typing part of a previous command.

This is one of the fastest ways to retrieve commands you’ve used before.

4. curl — Your Terminal's Internet Browser

curl allows you to interact with web servers directly from the terminal.

Check a website:

curl https://example.com

Download a file:

curl -O https://example.com/file.zip

Check HTTP headers:

curl -I https://example.com

Send a POST request:

curl -X POST \
-H "Content-Type: application/json" \
-d '{"name":"Raja"}' \
https://api.example.com/users

Why power users love curl

You can:

• Test APIs
• Download files
• Debug web applications
• Check HTTP headers
• Automate web requests

If you work with APIs, servers, or web applications, curl is essential.

5. ssh — Control Remote Machines From Anywhere

ssh allows you to securely connect to another computer.

ssh username@server-ip

For example:

ssh user@192.168.1.100

Once connected, you can manage the remote machine as if you were sitting in front of it.

Connect using a specific key

ssh -i ~/.ssh/mykey.pem user@server-ip

Run a command remotely

ssh user@server-ip "df -h"

This connects to the remote machine, runs df -h, and returns the output.

You don’t always need to manually log in to a server to perform a task.

6. rsync — Copy Files Without Wasting Time

rsync is one of the most useful tools for transferring and synchronizing files.

Copy a folder:

rsync -av source/ destination/

Copy files to a remote server:

rsync -av project/ user@server:/home/user/project/

The real advantage?

rsync transfers only the changed parts of files during subsequent runs.

That makes it extremely useful for:

• Backups
• Server deployments
• Large datasets
• Synchronizing research data

Power-user example

rsync -avz --progress project/ user@server:/backup/project/

Here:

• -a preserves file attributes
• -v shows detailed output
• -z compresses data during transfer
• --progress shows transfer progress

If you regularly move large files, learn rsync.

7. tail — Watch Logs in Real Time

When something goes wrong on a Linux server, the answer is often hiding inside a log file.

View the last 10 lines:

tail application.log

View the last 100 lines:

tail -n 100 application.log

Follow a log in real time:

tail -f application.log

This command is incredibly useful when monitoring applications.

Example

tail -f /var/log/syslog

Or for a web server:

tail -f /var/log/nginx/access.log

You can literally watch new log entries appear as they happen.

8. df and du — Find Out Where Your Disk Space Went

Your system says:

Disk space: 100% full.

Now what?

Start with:

df -h

This shows disk usage in a human-readable format.

Example:

Filesystem      Size  Used Avail Use%
/dev/sda1       100G   92G   8G  92%

But df only tells you which disk is full.

To find what is consuming the space, use:

du -sh *

Check the size of directories:

du -sh /home/*

Find the largest directories:

du -sh * | sort -h

This is one of the most useful troubleshooting workflows in Linux.

9. ps and kill — Take Control of Processes

Every program running on Linux is a process.

View running processes:

ps aux

Search for a specific process:

ps aux | grep python

You can also use:

pgrep python

If a process becomes unresponsive, you can terminate it.

kill PID

For example:

kill 2458

If the process refuses to stop:

kill -9 2458

⚠️ Use kill -9 carefully.

It forcefully terminates a process without allowing it to clean up resources.

A better approach is to try the normal kill command first.

10. chmod — Control Who Can Do What

Linux is built around permissions.

The chmod command changes file permissions.

Make a script executable:

chmod +x script.sh

Now you can run:

./script.sh

Set specific permissions:

chmod 755 script.sh

The numbers represent permissions for:

Owner | Group | Others

Where:

4 = Read
2 = Write
1 = Execute

So:

7 = Read + Write + Execute
5 = Read + Execute

Therefore:

chmod 755 script.sh

Means:

Owner  → Read, Write, Execute
Group  → Read, Execute
Others → Read, Execute

Understanding permissions is essential if you work with servers, scripts, or shared systems.

The Real Power Is in Combining Commands

The real magic of Linux isn’t just knowing individual commands.

It’s combining them.

For example:

ps aux | grep python

Or:

du -sh * | sort -h

Or:

history | grep docker

The pipe symbol:

|

takes the output of one command and sends it to another.

This allows you to build surprisingly powerful workflows from simple tools.

Bonus: Learn man

Whenever you forget how a command works:

man command_name

For example:

man rsync

This opens the official manual.

Want to know what options grep supports?

man grep

You don’t need to memorize everything.

Power users don’t necessarily remember every option.

They know how to find the information they need quickly.

Final Thoughts

You don’t become a Linux power user by memorizing 500 commands.

You become one by learning a handful of tools well enough to solve real problems.

Start with these:

• grep for searching
• find for locating files
• history for faster workflows
• curl for web requests
• ssh for remote systems
• rsync for file synchronization
• tail for logs
• df and du for disk troubleshooting
• ps and kill for process management
• chmod for permissions

Learn one command at a time.

Use it repeatedly.

Experiment with its options.

Eventually, the terminal stops feeling like a place where you type commands.

It becomes a place where you solve problems.

Which Linux command do you use the most?

Let me know in the comments.

Follow for more practical Linux, Python, bioinformatics, and research computing tutorials.

Most people think the future of AI work will be defined by bigger models.

Better reasoning. Longer context. More automation.

All of that matters. But sometimes the most important changes appear in smaller interface details: a button, a workflow, or a command.

Instead of writing a long prompt and hoping the agent understands your intention, slash commands make the mode of work explicit. Do you want the agent to finish the task without interrupting you? Ask it with /goal. Do you want it to question you before starting? Use /grill-me. Do you want the work to happen later or repeatedly? Use /schedule. Do you want the agent to use the browser? Use /browser.

As AI systems become more agentic, we do not only need smarter AI. We need clearer ways to direct it.

Why Slash Commands Matter

Traditional chatbots work like conversations.

You ask a question. The AI answers.

That model is useful for brainstorming, writing, summarizing, and quick problem-solving. But agentic systems are different: they can take actions, use tools, inspect files, browse the web, run tasks, and continue working across multiple steps.

That creates a new challenge:

How do we control the agent’s behavior without writing a complicated instruction every time?

Slash commands are one answer. They act like work modes, telling the agent not only what to do, but how to approach the task.

For office workers, this is easy to understand. We already use different modes of collaboration every day.

Sometimes we tell a colleague, “Please handle this completely and send me the final version.” Other times we say, “Ask me questions first,” “Remind me every Friday,” or “Check the website and verify the details.”

Antigravity 2.0 turns those everyday patterns into explicit AI commands.

/goal: Finish the Task, Do Not Stop Halfway

The /goal command tells the agent to keep working until the task is complete.

That matters because normal prompting often stops too early. An assistant may give you a plan, ask for confirmation after each step, or summarize what it would do instead of producing the final result.

/goal changes the expectation from advice to completion.

Imagine you need to prepare a weekly status report for your manager.

You could write:

/goal Create this week's project status report using the meeting notes, task updates, and pending action items. Organize it into completed work, current blockers, next steps, and decisions needed. Return only the final polished report.

Use /goal when the task has a clear finish line, such as:

• finish a draft
• clean up a document
• summarize a long set of notes

The key idea is completion. You are not asking for suggestions; you are delegating a task.

/grill-me: Ask Questions Before Starting

The /grill-me command tells the agent to pause and ask clarifying questions before it starts.

This is useful because many workplace tasks fail at the instruction stage. We assume context, forget deadlines, skip audience details, or leave out constraints that feel obvious to us. If the prompt is vague, an agent may confidently produce the wrong output.

/grill-me helps turn unclear intent into a sharper brief.

Imagine your manager asks you to prepare a presentation for an upcoming leadership meeting.

You could write:

/grill-me I need to prepare a presentation for next week's leadership meeting about our team's quarterly performance. Ask me the important questions before creating the outline.

The agent might ask:

• Who is the audience?
• How long should the presentation be?
• What decision should leadership make after seeing it?

Use /grill-me when the task is important, ambiguous, or high-stakes, such as:

• presentations
• emails to leadership
• project plans

The key idea is alignment. Before the agent acts, it helps you clarify what success looks like.

/schedule: Make AI Work Part of the Calendar

The /schedule command lets you run an instruction later or on a recurring schedule.

Most AI assistants are reactive: they wait for you to ask. /schedule makes the work more proactive by letting a recurring task happen at the right time without a fresh prompt every time.

Imagine you want a weekly reminder of open action items before your Monday team meeting.

You could write:

/schedule Every Monday at 8:30 AM, summarize the open action items from last week's meeting notes and prepare a short list of what I should follow up on before the team meeting.

This is useful for recurring office tasks such as:

• weekly reports
• meeting preparation
• follow-up reminders

Use /schedule when the task is:

• recurring
• time-sensitive
• easy to forget

The key idea is rhythm. The AI becomes part of your calendar, not just your chat window.

/browser: Verify Information From the Web

The /browser command tells the agent to use browser capabilities.

This matters because not every task can be answered from memory. Some work requires current information: pricing pages, event details, company announcements, product documentation, policy updates, or public deadlines.

With /browser, you are explicitly telling the agent to check instead of guess.

Imagine your team is preparing to renew a software subscription and you need current pricing before a budget discussion.

You could write:

/browser Check the current pricing page for our project management software, compare the available plans, and summarize which plan best fits a 25-person team.

Use /browser when the task requires:

• current pricing
• public documentation
• event details

The key idea is verification. You are telling the AI not to guess; you are telling it to check.

Final Thoughts

Google Antigravity 2.0’s slash commands may look like a small interface feature, but they point to a larger change in how we work with AI.

The next generation of AI tools will not only be judged by how much they know or how fast they respond. They will be judged by how clearly we can direct them.

That is what /goal, /grill-me, /schedule, and /browser make visible. Each command gives the agent a different working mode: finish the task, ask better questions, return at the right time, or verify information before answering.

For developers, this can make agentic software work easier to manage. For office workers, it makes AI feel less like a chatbot and more like a capable assistant that can be guided with precision.

The future of AI at work is not just about asking better questions. It is about giving better instructions to systems that can actually act on them.

OpenAI Codex can now be integrated directly into Visual Studio Code and Antigravity, allowing developers to generate, edit, debug, and refactor code without leaving the editor. The integration works through the official Codex extension and supports both ChatGPT login and API-based authentication.

Step 1: Open VS Code Extensions

In VS Code:

• Press Ctrl + Shift + X
• Open the Extensions Marketplace

Step 2: Search for Codex

Search for:

OpenAI Codex

Install the official Codex extension from OpenAI.

Step 3: Sign In

After installation, the extension provides multiple authentication methods:

Sign in with ChatGPT

Use API Key

Use device code

Option 1: Sign in with ChatGPT

• Click Sign in with ChatGPT
• A browser window will open and redirect you to the ChatGPT web portal
• Log in using your OpenAI account credentials
• Once authenticated, VS Code will automatically connect to your account

Option 2: Use an OpenAI API Key

If you prefer API-based authentication, you can connect Codex to VS Code using an OpenAI API key.

Go to https://platform.openai.com/

1. Click Create new secret key

After clicking “Create new secret key”, you will see the following configuration window:

2. Keep the following settings:

• Owned by → You
• Project → Default project

3. Enter a name for the key, for example:

VSCode-Key

4. Under Permissions:

• Select All for standard usage

5. Click:

Create secret key

After the key is generated:

• Copy the API key immediately
• OpenAI will not display it again

The generated key will look similar to:

sk-proj-xxxxxxxxxxxxxxxx

6. Connect the API Key to VS Code

After generating the API key, open VS Code and launch the Codex extension.

When prompted, paste the generated API key into the authentication window.

Once the key is verified, Codex will connect to your OpenAI account and become available directly inside VS Code.

Option 3: Use Device Code Authentication

Some setups may also provide Device Code Authentication.

In this method:

• VS Code displays a temporary device code
• You enter the code on the OpenAI authentication webpage
• After verification, VS Code connects automatically

This is useful when browser-based login is restricted.

Step 5: Start Using Codex

Once connected, Codex becomes available directly inside VS Code and can assist with:

• Code generation
• Debugging
• Refactoring
• Documentation
• Multi-file editing
• Terminal assistance

Suggestions appear inline while coding, making development faster and more interactive.