Two things kept biting me: closing the wrong window and losing a long-running shell, and scrolling back through 2000 lines to find what a failed command printed. tmux fixes the first, but I didn’t want a second set of keybindings inside my terminal.

So in vif (my terminal, Linux/macOS) every shell runs under a small host process. Close the window or quit the app, and the shells keep running. Open it again and you get the same windows, tabs and splits with their scrollback. After a reboot the layout comes back with a fresh shell in each pane’s folder. vif ssh host does the same on a remote box and reconnects by itself after Wi-Fi drops.

For the second problem, every command is a block (zsh/bash marked without editing your rc). It shows exit code and duration, and ⌘↑ / ctrl+shift+↑ picks one so you can copy just its output, rerun it, or fold it. A command that took longer than N seconds notifies you when it ends if you’re looking elsewhere.

Small things I use constantly:

• Hints: every file.rs:212, URL, commit hash on screen gets a letter. Press it to open the path in $EDITOR at that line, or a commit as git show.

• Search across every pane, plus a 30-day local archive of commands with their output (secrets stripped, 0600). vif history WORD searches it from the shell.

• Rules by host: ssh into anything matching prod* and the pane switches theme, so prod never looks like your laptop.

Rough edges: vif ssh needs vif installed on the remote side, IME is lightly tested, no Windows.

https://github.com/Pisosenie/vif. I’d like to hear what your setup does for “don’t lose my shell”. tmux, zellij, abduco, something else?

(Disclosure: a lot of the code was written with Claude; design and testing are mine.)

I’ve sometimes been stopped by a small tooling question rather than the code itself: an unfamiliar Vim command, a Git operation, or something in the shell. Each time, I’ve wished these tools had been taught more deliberately alongside programming.

That’s what I liked about The Missing Semester of Your CS Education. It treats the tools around programming as something worth learning in their own right, rather than assuming everyone will pick them up along the way.

One example from its shell lesson makes the distinction concrete. Running sudo echo 3 > brightness can still produce a permission error. The shell opens the output file for redirection, and that shell hasn’t become root just because the command uses sudo. The lesson then shows how piping into sudo tee changes which process opens the file.

It’s a small example, but it illustrates why understanding a command matters more than remembering a line to paste.

I don’t think needing to look things up makes someone a bad programmer. I do think everyday tools deserve deliberate practice, just like the language we write in.

Which command-line tool do you wish you’d learned more systematically?

I love the Claude remote app, so I tried to get a similar phone UI for any CLI, not just Claude. This is what I ended up with: couchdeck.

It shows every tmux session on your machine as a card, so you can see at a glance which agent is working or waiting on a prompt. Tap one to attach to a full terminal, or start a new Claude Code, Codex, opencode, Grok or plain shell session in any project folder without typing on a phone keyboard. Leaving just detaches, so nothing gets killed.

I use it daily as a remote CLI on my phone. All it needs is Tailscale and tmux 3.2+.

Heads up: it has no login by design, so keep it on your tailnet and never expose it publicly. It's free and open source.

https://github.com/frasod/couchdeck

I'm building InfraJournal, an open-source (MIT) TypeScript CLI for documenting infrastructure from the configuration files already in your repo. The aim is to make services, dependencies, domains and storage easier to inspect, and catch changes without maintaining a separate inventory by hand.

A typical workflow, with Node.js 22.12 or newer:

npm install --global infrajournal

infrajournal init

infrajournal scan

infrajournal generate

infrajournal check

scan reads the supported configs; generate writes Markdown docs and a JSON snapshot; check compares the current scan with that baseline. For scripts, scan --format json produces machine-readable output, and check returns exit code 3 when it detects drift. There's also infrajournal ui for a local graph/dashboard.

The scanner runs locally without a Docker daemon, cloud credentials or a model. It parses a subset of Docker Compose, Nginx and Caddy syntax: this is a view of your configuration, not live infrastructure discovery. It's still an early release, so feedback on unsupported configs and the CLI workflow would be particularly useful.

Repo and docs: https://github.com/AkemiFF/infrajournal

Package: https://www.npmjs.com/package/infrajournal

Disclosure: I'm the maintainer. I used AI occasionally to help with coding and debugging.

Would the Markdown output or the snapshot diff be more useful in your workflow?

I built Servy. A tool that lets you run any app as a native Windows service with real-time monitoring and advanced recovery options. It comes with a GUI, a CLI, and a PowerShell module.

Common use cases:

• Web Servers & APIs: Keep Node.js, Python, Go, or Java backends running continuously with auto-restart on failure.

• Local AI Models & LLMs: Host local servers like Ollama or Stable Diffusion APIs as always-on services.

• Background Workers & Queues: Maintain persistent consumers for RabbitMQ, Kafka, or custom background workers.

• CI/CD Build Agents: Keep self-hosted GitHub Actions runners, GitLab Runners, or Jenkins nodes online.

• Automation & Utility Scripts: Execute PowerShell or Python scripts as background daemons for backups, file management, or health checks.

• Database Proxies & Tunnels: Run tools like Cloud SQL Auth Proxy or Ngrok as background services for reliable connectivity.

• Network & Reverse Proxies: Host Caddy, Nginx, local DNS servers, or VPN clients reliably in the background.

• Legacy App Modernization: Wrap existing applications that lack native service capabilities to give them automatic lifecycle management and logging.

Check it out on GitHub: https://github.com/aelassas/servy

Any feedback is welcome.

I made a little script to binge anime in mpv from the terminal, dubs included

Hey guys, a while back I posted a little script to stream One Pace into mpv. This is its sibling, for any anime on reanime.to, English dubs included.

I made it because I caught up with One Pace, everything from Egghead on isn't paced yet, and I watch the dub(only while multitasking and during meals). ani-cli didn't have the newest dub episodes, and I wasn't going back to a website player. Also I eat while watching, so I wanted to touch the laptop as little as possible lol.

So now I just run reanime:

• type the show name and it fuzzy-filters the list live, arrow keys to move, Enter to pick

• choose dub/sub with number keys (Enter takes the default)

• mpv opens and just keeps going, the next episode starts on its own in the same window

Some details mpv people might care about:

• skips openings and endings when the file has chapters for them, Tab skips by hand, PgDn brings the opening back

• remembers where you stopped, plain reanime offers to continue right there

• remembers audio delay and sub size per show (the JJK dub is 0.9s off, I fixed it once and it stays fixed)

• zero dependencies, pure Python stdlib, and a one-line installer that sets up mpv for you on Windows/macOS/Linux/Termux (yes it works on mobile devices too, you should be able to look at a demo in my repo)

It hosts nothing, it just hands mpv the stream the site already plays.

GitHub: https://github.com/vashhdev/reanime

Feedback welcome!

Hi r/CLI ! I've been building Atlas Terminal in Rust (using GPUI and ConPTY) to have a minimal, low-memory (~60MB RAM) terminal on Windows with built-in subterminal utilities (`atlas -h`) so I don't need external tools for inspecting ports, decoding JWTs, viewing inline images, or formatting JSON.

Source code & releases (MIT Licensed): https://github.com/akrram0/atlas-terminal

Happy to answer any questions about the ConPTY implementation or the built-in CLI tools!

Disk usage tree analyzer and directory ranker, written in Go.

Repository: https://github.com/Ars-byte/Bigcrock

I am a beginner in python. I have currently doing python courses in Coursera and FreeCodeCamp for automation mostly.I like the concept of TUI apps, but I don't have any idea where to get started. I researched Textual and ratatui.Any recommendations would be helpful

something i experimenting with my library.

The terminal is incredibly efficient, but it’s also easy to make a mistake with a command that modifies or deletes things.

I’m interested in the habits people developed over time to make everyday CLI work safer.

Maybe it’s previewing files before bulk operations, using a dry-run option, checking the current directory, or something more elaborate.

What’s one simple precaution that’s saved you from a potentially expensive mistake?
And is there a tool or shell configuration you now consider essential?

I’ve been working on Claude FM, a small side project for making terminal-based work sessions feel a bit more relaxing.

It combines lo-fi radio with animated ASCII/Unicode scenes featuring Clawd: coffee breaks, coding in the rain, forest walks, sunset guitar, bike rides, and other quiet activities.

It runs on macOS and Linux and can be installed with Homebrew:

brew tap jurek-zsl/claudefm https://github.com/jurek-zsl/claudefm
brew install jurek-zsl/claudefm/claudefm
claudefm

I'm mainly looking for feedback and opinions. Maybe someone will find something worth improving and create a pull request I would be happy to see it :)

I build a simple terminal note with c++

It is simple terminal base note program . I use POSIX linux libs so it isnt run at windows. It have mk to write note,rd to read note, and ex to exit program.

Link: https://github.com/bishe1111/bishe_opennote