# Feeling Stuck in Linux? Read One Man Page a Day

Once you've spent years on an operating system, things soon start becoming stagnant. I hit that wall recently. I realized I'm spending most of my time at a full-time job, so I have very little time left to experiment—and experimentation is how you actually learn new things.

So, I came up with a plan. The idea is simple: read a random Linux man page daily (or realistically, whenever I have free time or feel like it), at least 3–4 times a week. It’s lightweight, flexible, and doesn’t require long focused sessions.

Today, I’ll walk you through exactly how I do it and how you can try the same.

### Man's Automation

Reading a random man page is easy, you can fully automate it with one command:

```shell
man -k . | grep ' (1)' | shuf -n 1 | awk '{print $1}' | xargs man
```

It's a simple one-line command that you can set as an alias. It lists all man pages, selects one at random, and opens it.

`grep ' (1)'` is the interesting part here.

If you don't already know, man pages are grouped into 8–9 sections. Some of the most notable are:

*   **1 → user commands**
    
*   **2 → system calls**
    
*   **3 → library functions**
    
*   **5 → file formats**
    
*   **8 → admin commands**
    
*   **9 → kernel internals**
    

With `grep ' (1)'`, we’re focusing only on user commands the ones you’ll actually interact with day to day. Starting here makes learning more approachable, since you build from practical usage before diving into deeper layers.  
Reading man pages for library functions or internals can be useful, but it’s usually more relevant when you’re working on something specific or intentionally exploring the system in depth.

Sometimes pure randomness isn’t what you want. You might be in the mood to explore a specific area like networking or processes.

That’s where this variation comes in:

```shell
man -k network | grep ' (1)' | shuf -n 1 | awk '{print $1}' | xargs man
```

The only change is the first part: `man -k network`.

Instead of listing everything, this searches for man pages that contain the word "network" in their name or description.

It’s not 100% accurate, but it’s good enough to cluster related commands together.

Here are a few solid categories to explore:

*   **filesystem** → file, directory, path, mount
    
*   **process** → process, signal, thread, job
    
*   **network** → network, socket, TCP, IP
    
*   **text** → text, stream, filter
    
*   **system** → system, kernel, memory
    
*   **user** → user, group, permission
    
*   **archive** → archive, compression, tar, gzip
    
*   **disk** → disk, partition, filesystem
    

### Mental Models

1.  **Just Explore  
    **This is my default mode. I open a random man page and read just enough to get a feel for it. Usually:
    
    *   NAME
        
    *   DESCRIPTION
        
    *   maybe a quick scan of OPTIONS
        
    
    If it clicks, I keep going. If not, I move on without guilt.
    
    Most days, I go through 3–5 man pages in about 5–10 minutes total. I also pair this with quick tools: `tldr`& `cheat.sh` for fast examples and practical usage snippets.
    
    > Always refer to `tldr` & [`cheat.sh`](http://cheat.sh) when reading man pages.
    
2.  **Go Deep**  
    Once in a while, I find a man page that complements my existing knowledge or fits well into a script I'm writing. That’s when I switch modes.
    
    I spend more time on it maybe a week or however long I feel like. I sit with ChatGPT on the side, remove the `grep (1)` filter, and explore system calls, library functions, and deeper internals.
    
    My recent work on Docker IPC falls under this category, and my current obsession with netfilter and TLS inspection fits here as well.
    
    > Explore widely, then go deep selectively.
    

### Complement Your Knowledge

Man pages are powerful but they’re not always the fastest way to understand something.

So I combine them with a few tools:

*   `tldr` and [`cheat.sh`](http://cheat.sh) for quick, real-world examples
    
*   Explainshell to break complex commands into understandable pieces
    
*   ChatGPT when I want explanations, comparisons, or “why would I use this?” insights
    

And most importantly: a running Linux system.

Reading is good but typing commands, <s>breaking things</s>, and fixing them is where things actually stick.

### TL;DR

You don’t need hours every day to improve your Linux skills.

You just need a system that fits into your life.

For me, it’s this:

*   Pick something randomly
    
*   Follow curiosity when it shows up
    
*   Go deeper when it matters
    

That’s it.

It keeps things fresh, avoids burnout, and slowly builds understanding over time.

Okay Bye... Have a Great Day Ahead!